diff --git a/.vscode/settings.json b/.vscode/settings.json deleted file mode 100644 index 7a89179..0000000 --- a/.vscode/settings.json +++ /dev/null @@ -1,8 +0,0 @@ -{ - "files.insertFinalNewline": true, - "rust-analyzer.cargo.features": "all", - "rust-analyzer.imports.granularity.enforce": true, - "rust-analyzer.imports.granularity.group": "module", - "rust-analyzer.imports.group.enable": true, - "evenBetterToml.formatter.columnWidth": 100, -} diff --git a/CHANGELOG.md b/CHANGELOG.md deleted file mode 100644 index bef60bc..0000000 --- a/CHANGELOG.md +++ /dev/null @@ -1,70 +0,0 @@ -# Changelog - -All notable changes to this project will be documented in this file. -The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/). - -Procedure when bumping the version number: -1. Update dependencies in a separate commit -2. Set version number in `Cargo.toml` -3. Add new section in this changelog -4. Commit with message `Bump version to X.Y.Z` -5. Create tag named `vX.Y.Z` -6. Push `master` and the new tag - -## Unreleased - -## v0.3.4 - 2025-03-8 - -### Added -- `Frame::set_bell` to print a bell character when the frame is displayed -- `widgets::bell` - -## v0.3.3 - 2025-02-28 - -### Fixed -- Rendering glitches in unicode-based with estimation - -## v0.3.2 - 2025-02-23 - -### Added -- Unicode-based grapheme width estimation method - -## v0.3.1 - 2025-02-21 - -### Fixed -- Rendering glitches, mainly related to emoji - -## v0.3.0 - 2024-11-06 - -### Added -- `Terminal::mark_dirty` - -### Changed -- **(breaking)** Updated dependencies - -## v0.2.3 - 2024-04-25 - -### Fixed -- Width measurements of ASCII control characters -- Toss messing up the terminal state - -## v0.2.2 - 2024-01-14 - -### Fixed -- Crash when drawing `widgets::Predrawn` with width 0 - -## v0.2.1 - 2024-01-05 - -### Added -- `Frame::set_title` -- `WidgetExt::title` -- `widgets::title` - -## v0.2.0 - 2023-08-31 - -### Changed -- **(breaking)** Updated dependencies - -## v0.1.0 - 2023-05-14 - -Initial release diff --git a/Cargo.toml b/Cargo.toml index 22967fc..5b3afd6 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,11 +1,13 @@ [package] name = "toss" -version = "0.3.4" +version = "0.1.0" edition = "2021" [dependencies] -async-trait = "0.1.83" -crossterm = "0.28.1" -unicode-linebreak = "0.1.5" -unicode-segmentation = "1.12.0" -unicode-width = "0.2.0" +crossterm = "0.23.2" +unicode-linebreak = "0.1.2" +unicode-segmentation = "1.9.0" +unicode-width = "0.1.9" + +[dev-dependencies] +unicode-blocks = "0.1.4" diff --git a/examples/hello_world.rs b/examples/hello_world.rs index 62c0c75..57cc976 100644 --- a/examples/hello_world.rs +++ b/examples/hello_world.rs @@ -1,30 +1,39 @@ use crossterm::event::Event; -use crossterm::style::Stylize; -use toss::{Frame, Pos, Style, Terminal}; +use crossterm::style::{ContentStyle, Stylize}; +use toss::frame::{Frame, Pos}; +use toss::terminal::{Redraw, Terminal}; fn draw(f: &mut Frame) { - f.write(Pos::new(0, 0), ("Hello world!", Style::new().green())); + f.write( + Pos::new(0, 0), + "Hello world!", + ContentStyle::default().green(), + ); f.write( Pos::new(0, 1), - ("Press any key to exit", Style::new().on_dark_blue()), + "Press any key to exit", + ContentStyle::default().on_dark_blue(), ); f.show_cursor(Pos::new(16, 0)); } fn render_frame(term: &mut Terminal) { - let mut dirty = true; - while dirty { + loop { + // Must be called before rendering, otherwise the terminal has out-of-date + // size information and will present garbage. term.autoresize().unwrap(); + draw(term.frame()); - term.present().unwrap(); - dirty = term.measure_widths().unwrap(); + + if term.present().unwrap() == Redraw::NotRequired { + break; + } } } fn main() { // Automatically enters alternate screen and enables raw mode let mut term = Terminal::new().unwrap(); - term.set_measuring(true); loop { // Render and display a frame. A full frame is displayed on the terminal diff --git a/examples/hello_world_widgets.rs b/examples/hello_world_widgets.rs deleted file mode 100644 index 000cf91..0000000 --- a/examples/hello_world_widgets.rs +++ /dev/null @@ -1,47 +0,0 @@ -use std::io; - -use crossterm::event::Event; -use crossterm::style::Stylize; -use toss::widgets::{BorderLook, Text}; -use toss::{Style, Styled, Terminal, Widget, WidgetExt}; - -fn widget() -> impl Widget { - let styled = Styled::new("Hello world!", Style::new().dark_green()) - .then_plain("\n") - .then("Press any key to exit", Style::new().on_dark_blue()); - Text::new(styled) - .padding() - .with_horizontal(1) - .border() - .with_look(BorderLook::LINE_DOUBLE) - .with_style(Style::new().dark_red()) - .background() - .with_style(Style::new().on_yellow().opaque()) - .float() - .with_all(0.5) -} - -fn render_frame(term: &mut Terminal) { - let mut dirty = true; - while dirty { - term.present_widget(widget()).unwrap(); - dirty = term.measure_widths().unwrap(); - } -} - -fn main() { - // Automatically enters alternate screen and enables raw mode - let mut term = Terminal::new().unwrap(); - term.set_measuring(true); - - loop { - // Render and display a frame. A full frame is displayed on the terminal - // once this function exits. - render_frame(&mut term); - - // Exit if the user presses any buttons - if !matches!(crossterm::event::read().unwrap(), Event::Resize(_, _)) { - break; - } - } -} diff --git a/examples/measure_widths.rs b/examples/measure_widths.rs new file mode 100644 index 0000000..1a05d26 --- /dev/null +++ b/examples/measure_widths.rs @@ -0,0 +1,375 @@ +use std::io; + +use crossterm::cursor::MoveTo; +use crossterm::execute; +use crossterm::style::Print; +use crossterm::terminal::{Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen}; +use unicode_blocks::UnicodeBlock; +use unicode_width::UnicodeWidthChar; + +use unicode_blocks as ub; + +fn measure_width(c: char) { + if let Some(predicted_width) = c.width() { + execute!( + io::stdout(), + Clear(ClearType::CurrentLine), + MoveTo(0, 1), + Print(c), + ) + .unwrap(); + let actual_width: usize = crossterm::cursor::position().unwrap().0.into(); + if predicted_width != actual_width { + eprintln!( + "{}: actual {actual_width}, expected {predicted_width}", + c as u32 + ); + } + } +} + +fn measure_widths(block: UnicodeBlock) { + execute!( + io::stdout(), + Clear(ClearType::All), + MoveTo(0, 0), + Print(block.name()), + MoveTo(0, 1), + ) + .unwrap(); + for c in block.start()..=block.end() { + if let Some(c) = char::from_u32(c) { + measure_width(c); + } else { + eprintln!("{c}: error"); + } + } +} + +fn main() { + let mut stdout = io::stdout(); + execute!(stdout, EnterAlternateScreen).unwrap(); + + measure_widths(ub::ADLAM); + measure_widths(ub::AEGEAN_NUMBERS); + measure_widths(ub::AHOM); + measure_widths(ub::ALCHEMICAL_SYMBOLS); + measure_widths(ub::ALPHABETIC_PRESENTATION_FORMS); + measure_widths(ub::ANATOLIAN_HIEROGLYPHS); + measure_widths(ub::ANCIENT_GREEK_MUSICAL_NOTATION); + measure_widths(ub::ANCIENT_GREEK_NUMBERS); + measure_widths(ub::ANCIENT_SYMBOLS); + measure_widths(ub::ARABIC); + measure_widths(ub::ARABIC_EXTENDED_A); + measure_widths(ub::ARABIC_EXTENDED_B); + measure_widths(ub::ARABIC_MATHEMATICAL_ALPHABETIC_SYMBOLS); + measure_widths(ub::ARABIC_PRESENTATION_FORMS_A); + measure_widths(ub::ARABIC_PRESENTATION_FORMS_B); + measure_widths(ub::ARABIC_SUPPLEMENT); + measure_widths(ub::ARMENIAN); + measure_widths(ub::ARROWS); + measure_widths(ub::AVESTAN); + measure_widths(ub::BALINESE); + measure_widths(ub::BAMUM); + measure_widths(ub::BAMUM_SUPPLEMENT); + measure_widths(ub::BASIC_LATIN); + measure_widths(ub::BASSA_VAH); + measure_widths(ub::BATAK); + measure_widths(ub::BENGALI); + measure_widths(ub::BHAIKSUKI); + measure_widths(ub::BLOCK_ELEMENTS); + measure_widths(ub::BOPOMOFO); + measure_widths(ub::BOPOMOFO_EXTENDED); + measure_widths(ub::BOX_DRAWING); + measure_widths(ub::BRAHMI); + measure_widths(ub::BRAILLE_PATTERNS); + measure_widths(ub::BUGINESE); + measure_widths(ub::BUHID); + measure_widths(ub::BYZANTINE_MUSICAL_SYMBOLS); + measure_widths(ub::CARIAN); + measure_widths(ub::CAUCASIAN_ALBANIAN); + measure_widths(ub::CHAKMA); + measure_widths(ub::CHAM); + measure_widths(ub::CHEROKEE); + measure_widths(ub::CHEROKEE_SUPPLEMENT); + measure_widths(ub::CHESS_SYMBOLS); + measure_widths(ub::CHORASMIAN); + measure_widths(ub::CJK_COMPATIBILITY); + measure_widths(ub::CJK_COMPATIBILITY_FORMS); + measure_widths(ub::CJK_COMPATIBILITY_IDEOGRAPHS); + measure_widths(ub::CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT); + measure_widths(ub::CJK_RADICALS_SUPPLEMENT); + measure_widths(ub::CJK_STROKES); + measure_widths(ub::CJK_SYMBOLS_AND_PUNCTUATION); + measure_widths(ub::CJK_UNIFIED_IDEOGRAPHS); + measure_widths(ub::CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A); + measure_widths(ub::CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B); + measure_widths(ub::CJK_UNIFIED_IDEOGRAPHS_EXTENSION_C); + measure_widths(ub::CJK_UNIFIED_IDEOGRAPHS_EXTENSION_D); + measure_widths(ub::CJK_UNIFIED_IDEOGRAPHS_EXTENSION_E); + measure_widths(ub::CJK_UNIFIED_IDEOGRAPHS_EXTENSION_F); + measure_widths(ub::CJK_UNIFIED_IDEOGRAPHS_EXTENSION_G); + measure_widths(ub::COMBINING_DIACRITICAL_MARKS); + measure_widths(ub::COMBINING_DIACRITICAL_MARKS_EXTENDED); + measure_widths(ub::COMBINING_DIACRITICAL_MARKS_FOR_SYMBOLS); + measure_widths(ub::COMBINING_DIACRITICAL_MARKS_SUPPLEMENT); + measure_widths(ub::COMBINING_HALF_MARKS); + measure_widths(ub::COMMON_INDIC_NUMBER_FORMS); + measure_widths(ub::CONTROL_PICTURES); + measure_widths(ub::COPTIC); + measure_widths(ub::COPTIC_EPACT_NUMBERS); + measure_widths(ub::COUNTING_ROD_NUMERALS); + measure_widths(ub::CUNEIFORM); + measure_widths(ub::CUNEIFORM_NUMBERS_AND_PUNCTUATION); + measure_widths(ub::CURRENCY_SYMBOLS); + measure_widths(ub::CYPRIOT_SYLLABARY); + measure_widths(ub::CYPRO_MINOAN); + measure_widths(ub::CYRILLIC); + measure_widths(ub::CYRILLIC_EXTENDED_A); + measure_widths(ub::CYRILLIC_EXTENDED_B); + measure_widths(ub::CYRILLIC_EXTENDED_C); + measure_widths(ub::CYRILLIC_SUPPLEMENT); + measure_widths(ub::DESERET); + measure_widths(ub::DEVANAGARI); + measure_widths(ub::DEVANAGARI_EXTENDED); + measure_widths(ub::DINGBATS); + measure_widths(ub::DIVES_AKURU); + measure_widths(ub::DOGRA); + measure_widths(ub::DOMINO_TILES); + measure_widths(ub::DUPLOYAN); + measure_widths(ub::EARLY_DYNASTIC_CUNEIFORM); + measure_widths(ub::EGYPTIAN_HIEROGLYPHS); + measure_widths(ub::EGYPTIAN_HIEROGLYPH_FORMAT_CONTROLS); + measure_widths(ub::ELBASAN); + measure_widths(ub::ELYMAIC); + measure_widths(ub::EMOTICONS); + measure_widths(ub::ENCLOSED_ALPHANUMERICS); + measure_widths(ub::ENCLOSED_ALPHANUMERIC_SUPPLEMENT); + measure_widths(ub::ENCLOSED_CJK_LETTERS_AND_MONTHS); + measure_widths(ub::ENCLOSED_IDEOGRAPHIC_SUPPLEMENT); + measure_widths(ub::ETHIOPIC); + measure_widths(ub::ETHIOPIC_EXTENDED); + measure_widths(ub::ETHIOPIC_EXTENDED_A); + measure_widths(ub::ETHIOPIC_EXTENDED_B); + measure_widths(ub::ETHIOPIC_SUPPLEMENT); + measure_widths(ub::GENERAL_PUNCTUATION); + measure_widths(ub::GEOMETRIC_SHAPES); + measure_widths(ub::GEOMETRIC_SHAPES_EXTENDED); + measure_widths(ub::GEORGIAN); + measure_widths(ub::GEORGIAN_EXTENDED); + measure_widths(ub::GEORGIAN_SUPPLEMENT); + measure_widths(ub::GLAGOLITIC); + measure_widths(ub::GLAGOLITIC_SUPPLEMENT); + measure_widths(ub::GOTHIC); + measure_widths(ub::GRANTHA); + measure_widths(ub::GREEK_AND_COPTIC); + measure_widths(ub::GREEK_EXTENDED); + measure_widths(ub::GUJARATI); + measure_widths(ub::GUNJALA_GONDI); + measure_widths(ub::GURMUKHI); + measure_widths(ub::HALFWIDTH_AND_FULLWIDTH_FORMS); + measure_widths(ub::HANGUL_COMPATIBILITY_JAMO); + measure_widths(ub::HANGUL_JAMO); + measure_widths(ub::HANGUL_JAMO_EXTENDED_A); + measure_widths(ub::HANGUL_JAMO_EXTENDED_B); + measure_widths(ub::HANGUL_SYLLABLES); + measure_widths(ub::HANIFI_ROHINGYA); + measure_widths(ub::HANUNOO); + measure_widths(ub::HATRAN); + measure_widths(ub::HEBREW); + // measure_widths(ub::HIGH_PRIVATE_USE_SURROGATES); + // measure_widths(ub::HIGH_SURROGATES); + measure_widths(ub::HIRAGANA); + measure_widths(ub::IDEOGRAPHIC_DESCRIPTION_CHARACTERS); + measure_widths(ub::IDEOGRAPHIC_SYMBOLS_AND_PUNCTUATION); + measure_widths(ub::IMPERIAL_ARAMAIC); + measure_widths(ub::INDIC_SIYAQ_NUMBERS); + measure_widths(ub::INSCRIPTIONAL_PAHLAVI); + measure_widths(ub::INSCRIPTIONAL_PARTHIAN); + measure_widths(ub::IPA_EXTENSIONS); + measure_widths(ub::JAVANESE); + measure_widths(ub::KAITHI); + measure_widths(ub::KANA_EXTENDED_A); + measure_widths(ub::KANA_EXTENDED_B); + measure_widths(ub::KANA_SUPPLEMENT); + measure_widths(ub::KANBUN); + measure_widths(ub::KANGXI_RADICALS); + measure_widths(ub::KANNADA); + measure_widths(ub::KATAKANA); + measure_widths(ub::KATAKANA_PHONETIC_EXTENSIONS); + measure_widths(ub::KAYAH_LI); + measure_widths(ub::KHAROSHTHI); + measure_widths(ub::KHITAN_SMALL_SCRIPT); + measure_widths(ub::KHMER); + measure_widths(ub::KHMER_SYMBOLS); + measure_widths(ub::KHOJKI); + measure_widths(ub::KHUDAWADI); + measure_widths(ub::LAO); + measure_widths(ub::LATIN_1_SUPPLEMENT); + measure_widths(ub::LATIN_EXTENDED_A); + measure_widths(ub::LATIN_EXTENDED_ADDITIONAL); + measure_widths(ub::LATIN_EXTENDED_B); + measure_widths(ub::LATIN_EXTENDED_C); + measure_widths(ub::LATIN_EXTENDED_D); + measure_widths(ub::LATIN_EXTENDED_E); + measure_widths(ub::LATIN_EXTENDED_F); + measure_widths(ub::LATIN_EXTENDED_G); + measure_widths(ub::LEPCHA); + measure_widths(ub::LETTERLIKE_SYMBOLS); + measure_widths(ub::LIMBU); + measure_widths(ub::LINEAR_A); + measure_widths(ub::LINEAR_B_IDEOGRAMS); + measure_widths(ub::LINEAR_B_SYLLABARY); + measure_widths(ub::LISU); + measure_widths(ub::LISU_SUPPLEMENT); + // measure_widths(ub::LOW_SURROGATES); + measure_widths(ub::LYCIAN); + measure_widths(ub::LYDIAN); + measure_widths(ub::MAHAJANI); + measure_widths(ub::MAHJONG_TILES); + measure_widths(ub::MAKASAR); + measure_widths(ub::MALAYALAM); + measure_widths(ub::MANDAIC); + measure_widths(ub::MANICHAEAN); + measure_widths(ub::MARCHEN); + measure_widths(ub::MASARAM_GONDI); + measure_widths(ub::MATHEMATICAL_ALPHANUMERIC_SYMBOLS); + measure_widths(ub::MATHEMATICAL_OPERATORS); + measure_widths(ub::MAYAN_NUMERALS); + measure_widths(ub::MEDEFAIDRIN); + measure_widths(ub::MEETEI_MAYEK); + measure_widths(ub::MEETEI_MAYEK_EXTENSIONS); + measure_widths(ub::MENDE_KIKAKUI); + measure_widths(ub::MEROITIC_CURSIVE); + measure_widths(ub::MEROITIC_HIEROGLYPHS); + measure_widths(ub::MIAO); + measure_widths(ub::MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A); + measure_widths(ub::MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B); + measure_widths(ub::MISCELLANEOUS_SYMBOLS); + measure_widths(ub::MISCELLANEOUS_SYMBOLS_AND_ARROWS); + measure_widths(ub::MISCELLANEOUS_SYMBOLS_AND_PICTOGRAPHS); + measure_widths(ub::MISCELLANEOUS_TECHNICAL); + measure_widths(ub::MODI); + measure_widths(ub::MODIFIER_TONE_LETTERS); + measure_widths(ub::MONGOLIAN); + measure_widths(ub::MONGOLIAN_SUPPLEMENT); + measure_widths(ub::MRO); + measure_widths(ub::MULTANI); + measure_widths(ub::MUSICAL_SYMBOLS); + measure_widths(ub::MYANMAR); + measure_widths(ub::MYANMAR_EXTENDED_A); + measure_widths(ub::MYANMAR_EXTENDED_B); + measure_widths(ub::NABATAEAN); + measure_widths(ub::NANDINAGARI); + measure_widths(ub::NEWA); + measure_widths(ub::NEW_TAI_LUE); + measure_widths(ub::NKO); + measure_widths(ub::NUMBER_FORMS); + measure_widths(ub::NUSHU); + measure_widths(ub::NYIAKENG_PUACHUE_HMONG); + measure_widths(ub::OGHAM); + measure_widths(ub::OLD_HUNGARIAN); + measure_widths(ub::OLD_ITALIC); + measure_widths(ub::OLD_NORTH_ARABIAN); + measure_widths(ub::OLD_PERMIC); + measure_widths(ub::OLD_PERSIAN); + measure_widths(ub::OLD_SOGDIAN); + measure_widths(ub::OLD_SOUTH_ARABIAN); + measure_widths(ub::OLD_TURKIC); + measure_widths(ub::OLD_UYGHUR); + measure_widths(ub::OL_CHIKI); + measure_widths(ub::OPTICAL_CHARACTER_RECOGNITION); + measure_widths(ub::ORIYA); + measure_widths(ub::ORNAMENTAL_DINGBATS); + measure_widths(ub::OSAGE); + measure_widths(ub::OSMANYA); + measure_widths(ub::OTTOMAN_SIYAQ_NUMBERS); + measure_widths(ub::PAHAWH_HMONG); + measure_widths(ub::PALMYRENE); + measure_widths(ub::PAU_CIN_HAU); + measure_widths(ub::PHAGS_PA); + measure_widths(ub::PHAISTOS_DISC); + measure_widths(ub::PHOENICIAN); + measure_widths(ub::PHONETIC_EXTENSIONS); + measure_widths(ub::PHONETIC_EXTENSIONS_SUPPLEMENT); + measure_widths(ub::PLAYING_CARDS); + measure_widths(ub::PRIVATE_USE_AREA); + measure_widths(ub::PSALTER_PAHLAVI); + measure_widths(ub::REJANG); + measure_widths(ub::RUMI_NUMERAL_SYMBOLS); + measure_widths(ub::RUNIC); + measure_widths(ub::SAMARITAN); + measure_widths(ub::SAURASHTRA); + measure_widths(ub::SHARADA); + measure_widths(ub::SHAVIAN); + measure_widths(ub::SHORTHAND_FORMAT_CONTROLS); + measure_widths(ub::SIDDHAM); + measure_widths(ub::SINHALA); + measure_widths(ub::SINHALA_ARCHAIC_NUMBERS); + measure_widths(ub::SMALL_FORM_VARIANTS); + measure_widths(ub::SMALL_KANA_EXTENSION); + measure_widths(ub::SOGDIAN); + measure_widths(ub::SORA_SOMPENG); + measure_widths(ub::SOYOMBO); + measure_widths(ub::SPACING_MODIFIER_LETTERS); + measure_widths(ub::SPECIALS); + measure_widths(ub::SUNDANESE); + measure_widths(ub::SUNDANESE_SUPPLEMENT); + measure_widths(ub::SUPERSCRIPTS_AND_SUBSCRIPTS); + measure_widths(ub::SUPPLEMENTAL_ARROWS_A); + measure_widths(ub::SUPPLEMENTAL_ARROWS_B); + measure_widths(ub::SUPPLEMENTAL_ARROWS_C); + measure_widths(ub::SUPPLEMENTAL_MATHEMATICAL_OPERATORS); + measure_widths(ub::SUPPLEMENTAL_PUNCTUATION); + measure_widths(ub::SUPPLEMENTAL_SYMBOLS_AND_PICTOGRAPHS); + measure_widths(ub::SUPPLEMENTARY_PRIVATE_USE_AREA_A); + measure_widths(ub::SUPPLEMENTARY_PRIVATE_USE_AREA_B); + measure_widths(ub::SUTTON_SIGNWRITING); + measure_widths(ub::SYLOTI_NAGRI); + measure_widths(ub::SYMBOLS_AND_PICTOGRAPHS_EXTENDED_A); + measure_widths(ub::SYMBOLS_FOR_LEGACY_COMPUTING); + measure_widths(ub::SYRIAC); + measure_widths(ub::SYRIAC_SUPPLEMENT); + measure_widths(ub::TAGALOG); + measure_widths(ub::TAGBANWA); + measure_widths(ub::TAGS); + measure_widths(ub::TAI_LE); + measure_widths(ub::TAI_THAM); + measure_widths(ub::TAI_VIET); + measure_widths(ub::TAI_XUAN_JING_SYMBOLS); + measure_widths(ub::TAKRI); + measure_widths(ub::TAMIL); + measure_widths(ub::TAMIL_SUPPLEMENT); + measure_widths(ub::TANGSA); + measure_widths(ub::TANGUT); + measure_widths(ub::TANGUT_COMPONENTS); + measure_widths(ub::TANGUT_SUPPLEMENT); + measure_widths(ub::TELUGU); + measure_widths(ub::THAANA); + measure_widths(ub::THAI); + measure_widths(ub::TIBETAN); + measure_widths(ub::TIFINAGH); + measure_widths(ub::TIRHUTA); + measure_widths(ub::TOTO); + measure_widths(ub::TRANSPORT_AND_MAP_SYMBOLS); + measure_widths(ub::UGARITIC); + measure_widths(ub::UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS); + measure_widths(ub::UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED); + measure_widths(ub::UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS_EXTENDED_A); + measure_widths(ub::VAI); + measure_widths(ub::VARIATION_SELECTORS); + measure_widths(ub::VARIATION_SELECTORS_SUPPLEMENT); + measure_widths(ub::VEDIC_EXTENSIONS); + measure_widths(ub::VERTICAL_FORMS); + measure_widths(ub::VITHKUQI); + measure_widths(ub::WANCHO); + measure_widths(ub::WARANG_CITI); + measure_widths(ub::YEZIDI); + measure_widths(ub::YIJING_HEXAGRAM_SYMBOLS); + measure_widths(ub::YI_RADICALS); + measure_widths(ub::YI_SYLLABLES); + measure_widths(ub::ZANABAZAR_SQUARE); + measure_widths(ub::ZNAMENNY_MUSICAL_NOTATION); + + execute!(stdout, LeaveAlternateScreen).unwrap(); +} diff --git a/examples/overlapping_graphemes.rs b/examples/overlapping_graphemes.rs index c90c4ae..db98bae 100644 --- a/examples/overlapping_graphemes.rs +++ b/examples/overlapping_graphemes.rs @@ -1,67 +1,79 @@ use crossterm::event::Event; -use crossterm::style::Stylize; -use toss::{Frame, Pos, Style, Terminal}; +use crossterm::style::{ContentStyle, Stylize}; +use toss::frame::{Frame, Pos}; +use toss::terminal::{Redraw, Terminal}; fn draw(f: &mut Frame) { f.write( Pos::new(0, 0), "Writing over wide graphemes removes the entire overwritten grapheme.", + ContentStyle::default(), ); - let under = Style::new().white().on_dark_blue(); - let over = Style::new().black().on_dark_yellow(); + let under = ContentStyle::default().white().on_dark_blue(); + let over = ContentStyle::default().black().on_dark_yellow(); for i in 0..6 { let delta = i - 2; - f.write(Pos::new(2 + i * 7, 2), ("a😀", under)); - f.write(Pos::new(2 + i * 7, 3), ("a😀", under)); - f.write(Pos::new(2 + i * 7, 4), ("a😀", under)); - f.write(Pos::new(2 + i * 7 + delta, 3), ("b", over)); - f.write(Pos::new(2 + i * 7 + delta, 4), ("😈", over)); + f.write(Pos::new(2 + i * 7, 2), "a😀", under); + f.write(Pos::new(2 + i * 7, 3), "a😀", under); + f.write(Pos::new(2 + i * 7, 4), "a😀", under); + f.write(Pos::new(2 + i * 7 + delta, 3), "b", over); + f.write(Pos::new(2 + i * 7 + delta, 4), "😈", over); } f.write( Pos::new(0, 6), "Wide graphemes at the edges of the screen apply their style, but are not", + ContentStyle::default(), + ); + f.write( + Pos::new(0, 7), + "actually rendered.", + ContentStyle::default(), ); - f.write(Pos::new(0, 7), "actually rendered."); let x1 = -1; let x2 = f.size().width as i32 / 2 - 3; let x3 = f.size().width as i32 - 5; - f.write(Pos::new(x1, 9), ("123456", under)); - f.write(Pos::new(x1, 10), ("😀😀😀", under)); - f.write(Pos::new(x2, 9), ("123456", under)); - f.write(Pos::new(x2, 10), ("😀😀😀", under)); - f.write(Pos::new(x3, 9), ("123456", under)); - f.write(Pos::new(x3, 10), ("😀😀😀", under)); + f.write(Pos::new(x1, 9), "123456", under); + f.write(Pos::new(x1, 10), "😀😀😀", under); + f.write(Pos::new(x2, 9), "123456", under); + f.write(Pos::new(x2, 10), "😀😀😀", under); + f.write(Pos::new(x3, 9), "123456", under); + f.write(Pos::new(x3, 10), "😀😀😀", under); let scientist = "👩‍🔬"; f.write( Pos::new(0, 12), "Most terminals ignore the zero width joiner and display this female", + ContentStyle::default(), ); f.write( Pos::new(0, 13), "scientist emoji as a woman and a microscope: 👩‍🔬", + ContentStyle::default(), ); - for i in 0..(f.widthdb().width(scientist) + 4) { - f.write(Pos::new(2, 15 + i as i32), (scientist, under)); - f.write(Pos::new(i as i32, 15 + i as i32), ("x", over)); + for i in 0..(f.width(scientist) + 4) { + f.write(Pos::new(2, 15 + i as i32), scientist, under); + f.write(Pos::new(i as i32, 15 + i as i32), "x", over); } } fn render_frame(term: &mut Terminal) { - let mut dirty = true; - while dirty { + loop { + // Must be called before rendering, otherwise the terminal has out-of-date + // size information and will present garbage. term.autoresize().unwrap(); + draw(term.frame()); - term.present().unwrap(); - dirty = term.measure_widths().unwrap(); + + if term.present().unwrap() == Redraw::NotRequired { + break; + } } } fn main() { // Automatically enters alternate screen and enables raw mode let mut term = Terminal::new().unwrap(); - term.set_measuring(true); loop { // Render and display a frame. A full frame is displayed on the terminal diff --git a/examples/text_wrapping.rs b/examples/text_wrapping.rs index 5292378..f150142 100644 --- a/examples/text_wrapping.rs +++ b/examples/text_wrapping.rs @@ -1,5 +1,7 @@ use crossterm::event::Event; -use toss::{Frame, Pos, Styled, Terminal}; +use crossterm::style::ContentStyle; +use toss::frame::{Frame, Pos}; +use toss::terminal::{Redraw, Terminal}; fn draw(f: &mut Frame) { let text = concat!( @@ -12,46 +14,37 @@ fn draw(f: &mut Frame) { "This\u{00a0}sentence\u{00a0}is\u{00a0}separated\u{00a0}by\u{00a0}non-\u{2060}breaking\u{00a0}spaces.\n", "\n", "It can also properly handle wide graphemes (like emoji 🤔), ", - "including ones usually displayed incorrectly by terminal emulators, like 👩‍🔬 (a female scientist emoji).\n", - "\n", - "Finally, tabs are supported as well. ", - "The following text is rendered with a tab width of 4:\n", - "\tx\n", - "1\tx\n", - "12\tx\n", - "123\tx\n", - "1234\tx\n", - "12345\tx\n", - "123456\tx\n", - "1234567\tx\n", - "12345678\tx\n", - "123456789\tx\n", + "including ones usually displayed incorrectly by terminal emulators, like 👩‍🔬 (a female scientist emoji).", ); - let width = f.size().width.into(); - let breaks = f.widthdb().wrap(text, width); - let lines = Styled::new_plain(text).split_at_indices(&breaks); - for (i, mut line) in lines.into_iter().enumerate() { - line.trim_end(); - f.write(Pos::new(0, i as i32), line); + let breaks = f.wrap(text, f.size().width.into()); + let lines = toss::split_at_indices(text, &breaks); + for (i, line) in lines.iter().enumerate() { + f.write( + Pos::new(0, i as i32), + line.trim_end(), + ContentStyle::default(), + ); } } fn render_frame(term: &mut Terminal) { - let mut dirty = true; - while dirty { + loop { + // Must be called before rendering, otherwise the terminal has out-of-date + // size information and will present garbage. term.autoresize().unwrap(); + draw(term.frame()); - term.present().unwrap(); - dirty = term.measure_widths().unwrap(); + + if term.present().unwrap() == Redraw::NotRequired { + break; + } } } fn main() { // Automatically enters alternate screen and enables raw mode let mut term = Terminal::new().unwrap(); - term.set_measuring(true); - term.set_tab_width(4); loop { // Render and display a frame. A full frame is displayed on the terminal diff --git a/src/buffer.rs b/src/buffer.rs index 022145b..4707b53 100644 --- a/src/buffer.rs +++ b/src/buffer.rs @@ -1,8 +1,34 @@ -use std::ops::Range; - use crossterm::style::ContentStyle; +use unicode_segmentation::UnicodeSegmentation; -use crate::{Pos, Size, Style, Styled, WidthDb}; +use crate::widthdb::WidthDB; + +#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] +pub struct Size { + pub width: u16, + pub height: u16, +} + +impl Size { + pub const ZERO: Self = Self { + width: 0, + height: 0, + }; +} + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct Pos { + pub x: i32, + pub y: i32, +} + +impl Pos { + pub const ZERO: Self = Self { x: 0, y: 0 }; + + pub fn new(x: i32, y: i32) -> Self { + Self { x, y } + } +} #[derive(Debug, Clone, PartialEq, Eq)] pub struct Cell { @@ -23,93 +49,13 @@ impl Default for Cell { } } -#[derive(Debug, Clone, Copy)] -struct StackFrame { - pub pos: Pos, - pub size: Size, - pub drawable_area: Option<(Pos, Size)>, -} - -impl StackFrame { - fn intersect_areas( - a_start: Pos, - a_size: Size, - b_start: Pos, - b_size: Size, - ) -> Option<(Pos, Size)> { - // The first row/column that is not part of the area any more - let a_end = a_start + a_size; - let b_end = b_start + b_size; - - let x_start = a_start.x.max(b_start.x); - let x_end = a_end.x.min(b_end.x); - let y_start = a_start.y.max(b_start.y); - let y_end = a_end.y.min(b_end.y); - - if x_start < x_end && y_start < y_end { - let start = Pos::new(x_start, y_start); - let size = Size::new((x_end - x_start) as u16, (y_end - y_start) as u16); - Some((start, size)) - } else { - None - } - } - - fn then(&self, pos: Pos, size: Size) -> Self { - let pos = self.local_to_global(pos); - - let drawable_area = self - .drawable_area - .and_then(|(da_pos, da_size)| Self::intersect_areas(da_pos, da_size, pos, size)); - - Self { - pos, - size, - drawable_area, - } - } - - fn local_to_global(&self, local_pos: Pos) -> Pos { - local_pos + self.pos - } - - fn global_to_local(&self, global_pos: Pos) -> Pos { - global_pos - self.pos - } - - /// Ranges along the x and y axis where drawing is allowed, in global - /// coordinates. - fn legal_ranges(&self) -> Option<(Range, Range)> { - if let Some((pos, size)) = self.drawable_area { - let xrange = pos.x..pos.x + size.width as i32; - let yrange = pos.y..pos.y + size.height as i32; - Some((xrange, yrange)) - } else { - None - } - } -} - -#[derive(Debug, Default, Clone)] +#[derive(Debug, Default)] pub struct Buffer { size: Size, data: Vec, - cursor: Option, - - /// A stack of rectangular drawing areas. - /// - /// When rendering to the buffer with a nonempty stack, it behaves as if it - /// was the size of the topmost stack element, and characters are translated - /// by the position of the topmost stack element. No characters can be - /// placed outside the area described by the topmost stack element. - stack: Vec, } impl Buffer { - /// Index in `data` of the cell at the given position. The position must - /// be inside the buffer. - /// - /// Ignores the stack. fn index(&self, x: u16, y: u16) -> usize { assert!(x < self.size.width); assert!(y < self.size.height); @@ -121,65 +67,30 @@ impl Buffer { y * width + x } - /// A reference to the cell at the given position. The position must be - /// inside the buffer. - /// - /// Ignores the stack. - pub fn at(&self, x: u16, y: u16) -> &Cell { + pub(crate) fn at(&self, x: u16, y: u16) -> &Cell { assert!(x < self.size.width); assert!(y < self.size.height); - let i = self.index(x, y); &self.data[i] } - /// A mutable reference to the cell at the given position. The position must - /// be inside the buffer. - /// - /// Ignores the stack. fn at_mut(&mut self, x: u16, y: u16) -> &mut Cell { assert!(x < self.size.width); assert!(y < self.size.height); - let i = self.index(x, y); &mut self.data[i] } - fn current_frame(&self) -> StackFrame { - self.stack.last().copied().unwrap_or(StackFrame { - pos: Pos::ZERO, - size: self.size, - drawable_area: Some((Pos::ZERO, self.size)), - }) - } - - pub fn push(&mut self, pos: Pos, size: Size) { - self.stack.push(self.current_frame().then(pos, size)); - } - - pub fn pop(&mut self) { - self.stack.pop(); - } - - /// Size of the current drawable area, respecting the stack. pub fn size(&self) -> Size { - self.current_frame().size - } - - pub fn cursor(&self) -> Option { - self.cursor.map(|p| self.current_frame().global_to_local(p)) - } - - pub fn set_cursor(&mut self, pos: Option) { - self.cursor = pos.map(|p| self.current_frame().local_to_global(p)); + self.size } /// Resize the buffer and reset its contents. /// /// The buffer's contents are reset even if the buffer is already the - /// correct size. The stack is reset as well. + /// correct size. pub fn resize(&mut self, size: Size) { - if size == self.size { + if size == self.size() { self.data.fill_with(Cell::default); } else { let width: usize = size.width.into(); @@ -190,86 +101,58 @@ impl Buffer { self.data.clear(); self.data.resize_with(len, Cell::default); } - - self.cursor = None; - - self.stack.clear(); } - /// Reset the contents and stack of the buffer. + /// Reset the contents of the buffer. /// /// `buf.reset()` is equivalent to `buf.resize(buf.size())`. pub fn reset(&mut self) { - self.resize(self.size); + self.data.fill_with(Cell::default); } /// Remove the grapheme at the specified coordinates from the buffer. /// /// Removes the entire grapheme, not just the cell at the coordinates. - /// Preserves the style of the affected cells. Preserves the cursor. Works - /// even if the coordinates don't point to the beginning of the grapheme. - /// - /// Ignores the stack. + /// Preserves the style of the affected cells. Works even if the coordinates + /// don't point to the beginning of the grapheme. fn erase(&mut self, x: u16, y: u16) { let cell = self.at(x, y); let width: u16 = cell.width.into(); let offset: u16 = cell.offset.into(); - for x in (x - offset)..(x - offset + width) { let cell = self.at_mut(x, y); let style = cell.style; - *cell = Cell::default(); cell.style = style; } } - /// Write styled text to the buffer, respecting the width of individual - /// graphemes. - /// - /// The initial x position is considered the first column for tab width - /// calculations. - pub fn write(&mut self, widthdb: &mut WidthDb, pos: Pos, styled: &Styled) { - let frame = self.current_frame(); - let (xrange, yrange) = match frame.legal_ranges() { - Some(ranges) => ranges, - None => return, // No drawable area - }; - let pos = frame.local_to_global(pos); - if !yrange.contains(&pos.y) { - return; // Outside of drawable area + pub fn write( + &mut self, + widthdb: &mut WidthDB, + mut pos: Pos, + content: &str, + style: ContentStyle, + ) { + // If we're not even visible, there's nothing to do + if pos.y < 0 || pos.y >= self.size.height as i32 { + return; } let y = pos.y as u16; - let mut col: usize = 0; - for (_, style, grapheme) in styled.styled_grapheme_indices() { - let x = pos.x + col as i32; - let width = widthdb.grapheme_width(grapheme, col); - col += width as usize; - if grapheme == "\t" { - for dx in 0..width { - self.write_grapheme(&xrange, x + dx as i32, y, 1, " ", style); - } - } else if width > 0 { - self.write_grapheme(&xrange, x, y, width, grapheme, style); + for grapheme in content.graphemes(true) { + let width = widthdb.grapheme_width(grapheme); + if width > 0 { + self.write_grapheme(pos.x, y, width, grapheme, style); } + pos.x += width as i32; } } - /// Write a single grapheme to the buffer, respecting its width. - /// /// Assumes that `pos.y` is in range. - fn write_grapheme( - &mut self, - xrange: &Range, - x: i32, - y: u16, - width: u8, - grapheme: &str, - style: Style, - ) { - let min_x = xrange.start; - let max_x = xrange.end - 1; // Last possible cell + fn write_grapheme(&mut self, x: i32, y: u16, width: u8, grapheme: &str, style: ContentStyle) { + let min_x = 0; + let max_x = self.size.width as i32 - 1; // Last possible cell let start_x = x; let end_x = x + width as i32 - 1; // Coordinate of last cell @@ -280,13 +163,12 @@ impl Buffer { if start_x >= min_x && end_x <= max_x { // Fully visible, write actual grapheme - let base_style = self.at(start_x as u16, y).style; for offset in 0..width { let x = start_x as u16 + offset as u16; self.erase(x, y); *self.at_mut(x, y) = Cell { content: grapheme.to_string().into_boxed_str(), - style: style.cover(base_style), + style, width, offset, }; @@ -296,21 +178,13 @@ impl Buffer { let start_x = start_x.max(0) as u16; let end_x = end_x.min(max_x) as u16; for x in start_x..=end_x { - let base_style = self.at(x, y).style; self.erase(x, y); *self.at_mut(x, y) = Cell { - style: style.cover(base_style), + style, ..Default::default() }; } } - - if let Some(pos) = self.cursor { - if pos.y == y as i32 && start_x <= pos.x && pos.x <= end_x { - // The cursor lies within the bounds of the current grapheme and - self.cursor = None; - } - } } pub fn cells(&self) -> Cells<'_> { @@ -332,9 +206,6 @@ impl<'a> Iterator for Cells<'a> { type Item = (u16, u16, &'a Cell); fn next(&mut self) -> Option { - if self.x >= self.buffer.size.width { - return None; - } if self.y >= self.buffer.size.height { return None; } diff --git a/src/coords.rs b/src/coords.rs deleted file mode 100644 index 1735746..0000000 --- a/src/coords.rs +++ /dev/null @@ -1,153 +0,0 @@ -use std::ops::{Add, AddAssign, Neg, Sub, SubAssign}; - -/// Size in screen cells. -#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] -pub struct Size { - pub width: u16, - pub height: u16, -} - -impl Size { - pub const ZERO: Self = Self::new(0, 0); - - pub const fn new(width: u16, height: u16) -> Self { - Self { width, height } - } - - /// Add two [`Size`]s using [`u16::saturating_add`]. - pub const fn saturating_add(self, rhs: Self) -> Self { - Self::new( - self.width.saturating_add(rhs.width), - self.height.saturating_add(rhs.height), - ) - } - - /// Subtract two [`Size`]s using [`u16::saturating_sub`]. - pub const fn saturating_sub(self, rhs: Self) -> Self { - Self::new( - self.width.saturating_sub(rhs.width), - self.height.saturating_sub(rhs.height), - ) - } -} - -impl Add for Size { - type Output = Self; - - fn add(self, rhs: Self) -> Self { - Self::new(self.width + rhs.width, self.height + rhs.height) - } -} - -impl AddAssign for Size { - fn add_assign(&mut self, rhs: Self) { - self.width += rhs.width; - self.height += rhs.height; - } -} - -impl Sub for Size { - type Output = Self; - - fn sub(self, rhs: Self) -> Self { - Self::new(self.width - rhs.width, self.height - rhs.height) - } -} - -impl SubAssign for Size { - fn sub_assign(&mut self, rhs: Self) { - self.width -= rhs.width; - self.height -= rhs.height; - } -} - -/// Position in screen cell coordinates. -/// -/// The x axis points to the right. The y axis points down. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] -pub struct Pos { - pub x: i32, - pub y: i32, -} - -impl Pos { - pub const ZERO: Self = Self::new(0, 0); - - pub const fn new(x: i32, y: i32) -> Self { - Self { x, y } - } -} - -impl From for Pos { - fn from(s: Size) -> Self { - Self::new(s.width.into(), s.height.into()) - } -} - -impl Add for Pos { - type Output = Self; - - fn add(self, rhs: Self) -> Self { - Self::new(self.x + rhs.x, self.y + rhs.y) - } -} - -impl Add for Pos { - type Output = Self; - - fn add(self, rhs: Size) -> Self { - Self::new(self.x + rhs.width as i32, self.y + rhs.height as i32) - } -} - -impl AddAssign for Pos { - fn add_assign(&mut self, rhs: Self) { - self.x += rhs.x; - self.y += rhs.y; - } -} - -impl AddAssign for Pos { - fn add_assign(&mut self, rhs: Size) { - self.x += rhs.width as i32; - self.y += rhs.height as i32; - } -} - -impl Sub for Pos { - type Output = Self; - - fn sub(self, rhs: Self) -> Self { - Self::new(self.x - rhs.x, self.y - rhs.y) - } -} - -impl Sub for Pos { - type Output = Self; - - fn sub(self, rhs: Size) -> Self { - Self::new(self.x - rhs.width as i32, self.y - rhs.height as i32) - } -} - -impl SubAssign for Pos { - fn sub_assign(&mut self, rhs: Self) { - self.x -= rhs.x; - self.y -= rhs.y; - } -} - -impl SubAssign for Pos { - fn sub_assign(&mut self, rhs: Size) { - self.x -= rhs.width as i32; - self.y -= rhs.height as i32; - } -} - -impl Neg for Pos { - type Output = Self; - - fn neg(self) -> Self { - Self::new(-self.x, -self.y) - } -} diff --git a/src/frame.rs b/src/frame.rs index e42ba6b..f8c46af 100644 --- a/src/frame.rs +++ b/src/frame.rs @@ -1,40 +1,35 @@ //! Rendering the next frame. +use crossterm::style::ContentStyle; + use crate::buffer::Buffer; -use crate::{Pos, Size, Styled, WidthDb}; +pub use crate::buffer::{Pos, Size}; +use crate::widthdb::WidthDB; +use crate::wrap; #[derive(Debug, Default)] pub struct Frame { - pub(crate) widthdb: WidthDb, + pub(crate) widthdb: WidthDB, pub(crate) buffer: Buffer, - pub(crate) title: Option, - pub(crate) bell: bool, + cursor: Option, } impl Frame { - pub fn push(&mut self, pos: Pos, size: Size) { - self.buffer.push(pos, size); - } - - pub fn pop(&mut self) { - self.buffer.pop(); - } - pub fn size(&self) -> Size { self.buffer.size() } pub fn reset(&mut self) { self.buffer.reset(); - self.title = None; + self.cursor = None; } pub fn cursor(&self) -> Option { - self.buffer.cursor() + self.cursor } pub fn set_cursor(&mut self, pos: Option) { - self.buffer.set_cursor(pos); + self.cursor = pos; } pub fn show_cursor(&mut self, pos: Pos) { @@ -45,19 +40,27 @@ impl Frame { self.set_cursor(None); } - pub fn set_title(&mut self, title: Option) { - self.title = title; + /// Determine the width of a grapheme. + /// + /// If the width has not been measured yet, it is estimated using the + /// Unicode Standard Annex #11. + pub fn grapheme_width(&mut self, grapheme: &str) -> u8 { + self.widthdb.grapheme_width(grapheme) } - pub fn set_bell(&mut self, bell: bool) { - self.bell = bell; + /// Determine the width of a string based on its graphemes. + /// + /// If the width of a grapheme has not been measured yet, it is estimated + /// using the Unicode Standard Annex #11. + pub fn width(&mut self, s: &str) -> usize { + self.widthdb.width(s) } - pub fn widthdb(&mut self) -> &mut WidthDb { - &mut self.widthdb + pub fn wrap(&mut self, text: &str, width: usize) -> Vec { + wrap::wrap(text, width, &mut self.widthdb) } - pub fn write>(&mut self, pos: Pos, styled: S) { - self.buffer.write(&mut self.widthdb, pos, &styled.into()); + pub fn write(&mut self, pos: Pos, content: &str, style: ContentStyle) { + self.buffer.write(&mut self.widthdb, pos, content, style); } } diff --git a/src/lib.rs b/src/lib.rs index a204e8c..9cbdd9f 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,29 +1,7 @@ -#![forbid(unsafe_code)] -// Rustc lint groups -#![warn(future_incompatible)] -#![warn(rust_2018_idioms)] -#![warn(unused)] -// Rustc lints -#![warn(noop_method_call)] -#![warn(single_use_lifetimes)] -// Clippy lints -#![warn(clippy::use_self)] - mod buffer; -mod coords; -mod frame; -mod style; -mod styled; -mod terminal; -mod widget; -pub mod widgets; +pub mod frame; +pub mod terminal; mod widthdb; mod wrap; -pub use coords::*; -pub use frame::*; -pub use style::*; -pub use styled::*; -pub use terminal::*; -pub use widget::*; -pub use widthdb::*; +pub use wrap::split_at_indices; diff --git a/src/style.rs b/src/style.rs deleted file mode 100644 index 56c66ce..0000000 --- a/src/style.rs +++ /dev/null @@ -1,60 +0,0 @@ -use crossterm::style::{ContentStyle, Stylize}; - -fn merge_cs(base: ContentStyle, cover: ContentStyle) -> ContentStyle { - ContentStyle { - foreground_color: cover.foreground_color.or(base.foreground_color), - background_color: cover.background_color.or(base.background_color), - underline_color: cover.underline_color.or(base.underline_color), - attributes: cover.attributes, - } -} - -#[derive(Debug, Clone, Copy, Default)] -pub struct Style { - pub content_style: ContentStyle, - pub opaque: bool, -} - -impl Style { - pub fn new() -> Self { - Self::default() - } - - pub fn transparent(mut self) -> Self { - self.opaque = false; - self - } - - pub fn opaque(mut self) -> Self { - self.opaque = true; - self - } - - pub fn cover(self, base: ContentStyle) -> ContentStyle { - if self.opaque { - return self.content_style; - } - - merge_cs(base, self.content_style) - } -} - -impl AsRef for Style { - fn as_ref(&self) -> &ContentStyle { - &self.content_style - } -} - -impl AsMut for Style { - fn as_mut(&mut self) -> &mut ContentStyle { - &mut self.content_style - } -} - -impl Stylize for Style { - type Styled = Self; - - fn stylize(self) -> Self::Styled { - self - } -} diff --git a/src/styled.rs b/src/styled.rs deleted file mode 100644 index 33a8285..0000000 --- a/src/styled.rs +++ /dev/null @@ -1,195 +0,0 @@ -use std::iter::Peekable; -use std::slice; - -use unicode_segmentation::{GraphemeIndices, Graphemes, UnicodeSegmentation}; - -use crate::Style; - -#[derive(Debug, Default, Clone)] -pub struct Styled { - text: String, - /// List of `(style, until)` tuples. The style should be applied to all - /// chars in the range `prev_until..until`. - styles: Vec<(Style, usize)>, -} - -impl Styled { - pub fn new>(text: S, style: Style) -> Self { - Self::default().then(text, style) - } - - pub fn new_plain>(text: S) -> Self { - Self::default().then_plain(text) - } - - pub fn then>(mut self, text: S, style: Style) -> Self { - let text = text.as_ref(); - if !text.is_empty() { - self.text.push_str(text); - self.styles.push((style, self.text.len())); - } - self - } - - pub fn then_plain>(self, text: S) -> Self { - self.then(text, Style::new()) - } - - pub fn and_then(mut self, mut other: Self) -> Self { - let delta = self.text.len(); - for (_, until) in &mut other.styles { - *until += delta; - } - - self.text.push_str(&other.text); - self.styles.extend(other.styles); - self - } - - pub fn text(&self) -> &str { - &self.text - } - - pub fn split_at(self, mid: usize) -> (Self, Self) { - let (left_text, right_text) = self.text.split_at(mid); - - let mut left_styles = vec![]; - let mut right_styles = vec![]; - let mut from = 0; - for (style, until) in self.styles { - if from < mid { - left_styles.push((style, until.min(mid))); - } - if mid < until { - right_styles.push((style, until.saturating_sub(mid))); - } - from = until; - } - - let left = Self { - text: left_text.to_string(), - styles: left_styles, - }; - - let right = Self { - text: right_text.to_string(), - styles: right_styles, - }; - - (left, right) - } - - pub fn split_at_indices(self, indices: &[usize]) -> Vec { - let mut lines = vec![]; - - let mut rest = self; - let mut offset = 0; - - for i in indices { - let (left, right) = rest.split_at(i - offset); - lines.push(left); - rest = right; - offset = *i; - } - - lines.push(rest); - - lines - } - - pub fn trim_end(&mut self) { - self.text = self.text.trim_end().to_string(); - - let text_len = self.text.len(); - let mut styles_len = 0; - for (_, until) in &mut self.styles { - styles_len += 1; - if *until >= text_len { - *until = text_len; - break; - } - } - - while self.styles.len() > styles_len { - self.styles.pop(); - } - } -} - -////////////////////////////// -// Iterating over graphemes // -////////////////////////////// - -pub struct StyledGraphemeIndices<'a> { - text: GraphemeIndices<'a>, - styles: Peekable>, -} - -impl<'a> Iterator for StyledGraphemeIndices<'a> { - type Item = (usize, Style, &'a str); - - fn next(&mut self) -> Option { - let (gi, grapheme) = self.text.next()?; - let (mut style, mut until) = **self.styles.peek().expect("styles cover entire text"); - while gi >= until { - self.styles.next(); - (style, until) = **self.styles.peek().expect("styles cover entire text"); - } - Some((gi, style, grapheme)) - } -} - -impl Styled { - pub fn graphemes(&self) -> Graphemes<'_> { - self.text.graphemes(true) - } - - pub fn grapheme_indices(&self) -> GraphemeIndices<'_> { - self.text.grapheme_indices(true) - } - - pub fn styled_grapheme_indices(&self) -> StyledGraphemeIndices<'_> { - StyledGraphemeIndices { - text: self.grapheme_indices(), - styles: self.styles.iter().peekable(), - } - } -} - -////////////////////////// -// Converting to Styled // -////////////////////////// - -impl From<&str> for Styled { - fn from(text: &str) -> Self { - Self::new_plain(text) - } -} - -impl From for Styled { - fn from(text: String) -> Self { - Self::new_plain(text) - } -} - -impl> From<(S,)> for Styled { - fn from((text,): (S,)) -> Self { - Self::new_plain(text) - } -} - -impl> From<(S, Style)> for Styled { - fn from((text, style): (S, Style)) -> Self { - Self::new(text, style) - } -} - -impl> From<&[(S, Style)]> for Styled { - fn from(segments: &[(S, Style)]) -> Self { - let mut result = Self::default(); - for (text, style) in segments { - result = result.then(text, *style); - } - result - } -} diff --git a/src/terminal.rs b/src/terminal.rs index 07fe686..eb5645e 100644 --- a/src/terminal.rs +++ b/src/terminal.rs @@ -1,28 +1,22 @@ //! Displaying frames on a terminal. -use std::io::{self, Write}; -use std::mem; +use std::io::Write; +use std::{io, mem}; use crossterm::cursor::{Hide, MoveTo, Show}; -use crossterm::event::{ - DisableBracketedPaste, EnableBracketedPaste, KeyboardEnhancementFlags, - PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags, -}; -use crossterm::style::{Print, PrintStyledContent, StyledContent}; -use crossterm::terminal::{ - BeginSynchronizedUpdate, Clear, ClearType, EndSynchronizedUpdate, EnterAlternateScreen, - LeaveAlternateScreen, SetTitle, -}; +use crossterm::style::{PrintStyledContent, StyledContent}; +use crossterm::terminal::{Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen}; use crossterm::{ExecutableCommand, QueueableCommand}; -use crate::buffer::Buffer; -use crate::{AsyncWidget, Frame, Size, Widget, WidthDb, WidthEstimationMethod}; +use crate::buffer::{Buffer, Size}; +use crate::frame::Frame; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Redraw { + Required, + NotRequired, +} -/// Wrapper that manages terminal output. -/// -/// This struct (usually) wraps around stdout and handles showing things on the -/// terminal. It cleans up after itself when droppped, so it shouldn't leave the -/// terminal in a weird state even if your program crashes. pub struct Terminal { /// Render target. out: Box, @@ -37,17 +31,17 @@ pub struct Terminal { impl Drop for Terminal { fn drop(&mut self) { - let _ = self.suspend(); + let _ = crossterm::terminal::disable_raw_mode(); + let _ = self.out.execute(LeaveAlternateScreen); + let _ = self.out.execute(Show); } } impl Terminal { - /// Create a new [`Terminal`] that wraps stdout. pub fn new() -> io::Result { Self::with_target(Box::new(io::stdout())) } - /// Create a new terminal wrapping a custom output. pub fn with_target(out: Box) -> io::Result { let mut result = Self { out, @@ -55,136 +49,13 @@ impl Terminal { prev_frame_buffer: Buffer::default(), full_redraw: true, }; - result.unsuspend()?; - Ok(result) - } - - /// Temporarily restore the terminal state to normal. - /// - /// This is useful when running external programs the user should interact - /// with directly, for example a text editor. - /// - /// Call [`Self::unsuspend`] to return the terminal state before drawing and - /// presenting the next frame. - pub fn suspend(&mut self) -> io::Result<()> { - crossterm::terminal::disable_raw_mode()?; - #[cfg(not(windows))] - { - self.out.execute(PopKeyboardEnhancementFlags)?; - self.out.execute(DisableBracketedPaste)?; - } - self.out.execute(LeaveAlternateScreen)?; - self.out.execute(Show)?; - Ok(()) - } - - /// Restore the terminal state after calling [`Self::suspend`]. - /// - /// After calling this function, a new frame needs to be drawn and presented - /// by the application. The previous screen contents are **not** restored. - pub fn unsuspend(&mut self) -> io::Result<()> { crossterm::terminal::enable_raw_mode()?; - self.out.execute(EnterAlternateScreen)?; - #[cfg(not(windows))] - { - self.out.execute(EnableBracketedPaste)?; - self.out.execute(PushKeyboardEnhancementFlags( - KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES, - ))?; - } - self.full_redraw = true; - Ok(()) - } - - /// Set the tab width in columns. - /// - /// For more details, see [`Self::tab_width`]. - pub fn set_tab_width(&mut self, tab_width: u8) { - self.frame.widthdb.tab_width = tab_width; - } - - /// The tab width in columns. - /// - /// For accurate width calculations and consistency across terminals, tabs - /// are not printed to the terminal directly, but instead converted into - /// spaces. - pub fn tab_width(&self) -> u8 { - self.frame.widthdb.tab_width - } - - /// Set the grapheme width estimation method. - /// - /// For more details, see [`WidthEstimationMethod`]. - pub fn set_width_estimation_method(&mut self, method: WidthEstimationMethod) { - self.frame.widthdb.estimate = method; - } - - /// The grapheme width estimation method. - /// - /// For more details, see [`WidthEstimationMethod`]. - pub fn width_estimation_method(&mut self) -> WidthEstimationMethod { - self.frame.widthdb.estimate - } - - /// Enable or disable grapheme width measurements. - /// - /// For more details, see [`Self::measuring`]. - pub fn set_measuring(&mut self, active: bool) { - self.frame.widthdb.measure = active; - } - - /// Whether grapheme widths should be measured or estimated. - /// - /// Handling of wide characters is inconsistent from terminal emulator to - /// terminal emulator, and may even depend on the font the user is using. - /// - /// When enabled, any newly encountered graphemes are measured whenever - /// [`Self::measure_widths`] is called. This is done by clearing the screen, - /// printing the grapheme and measuring the resulting cursor position. - /// Because of this, the screen will flicker occasionally. However, grapheme - /// widths will always be accurate independent of the terminal - /// configuration. - /// - /// When disabled, the width of graphemes is estimated using the Unicode - /// Standard Annex #11. This usually works fine, but may break on some emoji - /// or other less commonly used character sequences. - pub fn measuring(&self) -> bool { - self.frame.widthdb.measure - } - - /// Whether any unmeasured graphemes were seen since the last call to - /// [`Self::measure_widths`]. - /// - /// Returns `true` whenever [`Self::measure_widths`] would return `true`. - pub fn measuring_required(&self) -> bool { - self.frame.widthdb.measuring_required() - } - - /// Measure widths of all unmeasured graphemes. - /// - /// If width measurements are disabled, this function does nothing. For more - /// info, see [`Self::measuring`]. - /// - /// Returns `true` if any new graphemes were measured and the screen must be - /// redrawn. Keep in mind that after redrawing the screen, graphemes may - /// have become visible that have not yet been measured. You should keep - /// re-measuring and re-drawing until this function returns `false`. - pub fn measure_widths(&mut self) -> io::Result { - if self.frame.widthdb.measuring_required() { - self.full_redraw = true; - self.frame.widthdb.measure_widths(&mut self.out)?; - Ok(true) - } else { - Ok(false) - } + result.out.execute(EnterAlternateScreen)?; + Ok(result) } /// Resize the frame and other internal buffers if the terminal size has /// changed. - /// - /// Should be called before drawing a frame and presenting it with - /// [`Self::present`]. It is not necessary to call this when using - /// [`Self::present_widget`] or [`Self::present_async_widget`]. pub fn autoresize(&mut self) -> io::Result<()> { let (width, height) = crossterm::terminal::size()?; let size = Size { width, height }; @@ -197,86 +68,42 @@ impl Terminal { Ok(()) } - /// The current frame. pub fn frame(&mut self) -> &mut Frame { &mut self.frame } - /// A database of grapheme widths. - pub fn widthdb(&mut self) -> &mut WidthDb { - &mut self.frame.widthdb - } - - /// Mark the terminal as dirty, forcing a full redraw whenever any variant - /// of [`Self::present`] is called. - pub fn mark_dirty(&mut self) { - self.full_redraw = true; - } - /// Display the current frame on the screen and prepare the next frame. - /// - /// Before drawing and presenting a frame, [`Self::measure_widths`] and - /// [`Self::autoresize`] should be called. + /// Returns `true` if an immediate redraw is required. /// /// After calling this function, the frame returned by [`Self::frame`] will /// be empty again and have no cursor position. - pub fn present(&mut self) -> io::Result<()> { - self.out.queue(BeginSynchronizedUpdate)?; - let result = self.draw_to_screen(); - self.out.queue(EndSynchronizedUpdate)?; - result?; + pub fn present(&mut self) -> io::Result { + if self.frame.widthdb.measuring_required() { + self.frame.widthdb.measure_widths(&mut self.out)?; + // Since we messed up the screen by measuring widths, we'll need to + // do a full redraw the next time around. + self.full_redraw = true; + // Throwing away the current frame because its content were rendered + // with unconfirmed width data. Also, this function guarantees that + // after it is called, the frame is empty. + self.frame.reset(); + return Ok(Redraw::Required); + } - self.out.flush()?; - - mem::swap(&mut self.prev_frame_buffer, &mut self.frame.buffer); - self.frame.reset(); - - Ok(()) - } - - /// Display a [`Widget`] on the screen. - /// - /// Before creating and presenting a widget, [`Self::measure_widths`] should - /// be called. There is no need to call [`Self::autoresize`]. - pub fn present_widget(&mut self, widget: W) -> Result<(), E> - where - E: From, - W: Widget, - { - self.autoresize()?; - widget.draw(self.frame())?; - self.present()?; - Ok(()) - } - - /// Display an [`AsyncWidget`] on the screen. - /// - /// Before creating and presenting a widget, [`Self::measure_widths`] should - /// be called. There is no need to call [`Self::autoresize`]. - pub async fn present_async_widget(&mut self, widget: W) -> Result<(), E> - where - E: From, - W: AsyncWidget, - { - self.autoresize()?; - widget.draw(self.frame()).await?; - self.present()?; - Ok(()) - } - - fn draw_to_screen(&mut self) -> io::Result<()> { if self.full_redraw { - self.out.queue(Clear(ClearType::All))?; + io::stdout().queue(Clear(ClearType::All))?; self.prev_frame_buffer.reset(); // Because the screen is now empty self.full_redraw = false; } self.draw_differences()?; self.update_cursor()?; - self.update_title()?; - self.ring_bell()?; + self.out.flush()?; - Ok(()) + mem::swap(&mut self.prev_frame_buffer, &mut self.frame.buffer); + self.frame.reset(); + + Ok(Redraw::NotRequired) } fn draw_differences(&mut self) -> io::Result<()> { @@ -309,19 +136,4 @@ impl Terminal { self.out.queue(Hide)?; Ok(()) } - - fn update_title(&mut self) -> io::Result<()> { - if let Some(title) = &self.frame.title { - self.out.queue(SetTitle(title.clone()))?; - } - Ok(()) - } - - fn ring_bell(&mut self) -> io::Result<()> { - if self.frame.bell { - self.out.queue(Print('\x07'))?; - } - self.frame.bell = false; - Ok(()) - } } diff --git a/src/widget.rs b/src/widget.rs deleted file mode 100644 index 356a047..0000000 --- a/src/widget.rs +++ /dev/null @@ -1,127 +0,0 @@ -use async_trait::async_trait; - -use crate::widgets::{ - Background, Border, Boxed, BoxedAsync, BoxedSendSync, Desync, Either2, Either3, Float, - JoinSegment, Layer2, Padding, Resize, Title, -}; -use crate::{Frame, Size, WidthDb}; - -// TODO Feature-gate these traits - -pub trait Widget { - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result; - - fn draw(self, frame: &mut Frame) -> Result<(), E>; -} - -#[async_trait] -pub trait AsyncWidget { - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result; - - async fn draw(self, frame: &mut Frame) -> Result<(), E>; -} - -pub trait WidgetExt: Sized { - fn background(self) -> Background { - Background::new(self) - } - - fn border(self) -> Border { - Border::new(self) - } - - fn boxed<'a, E>(self) -> Boxed<'a, E> - where - Self: Widget + 'a, - { - Boxed::new(self) - } - - fn boxed_send_sync<'a, E>(self) -> BoxedSendSync<'a, E> - where - Self: Widget + Send + Sync + 'a, - { - BoxedSendSync::new(self) - } - - fn boxed_async<'a, E>(self) -> BoxedAsync<'a, E> - where - Self: AsyncWidget + Send + Sync + 'a, - { - BoxedAsync::new(self) - } - - fn desync(self) -> Desync { - Desync(self) - } - - fn first2(self) -> Either2 { - Either2::First(self) - } - - fn second2(self) -> Either2 { - Either2::Second(self) - } - - fn first3(self) -> Either3 { - Either3::First(self) - } - - fn second3(self) -> Either3 { - Either3::Second(self) - } - - fn third3(self) -> Either3 { - Either3::Third(self) - } - - fn float(self) -> Float { - Float::new(self) - } - - fn segment(self) -> JoinSegment { - JoinSegment::new(self) - } - - fn below(self, above: W) -> Layer2 { - Layer2::new(self, above) - } - - fn above(self, below: W) -> Layer2 { - Layer2::new(below, self) - } - - fn padding(self) -> Padding { - Padding::new(self) - } - - fn resize(self) -> Resize { - Resize::new(self) - } - - fn title(self, title: S) -> Title { - Title::new(self, title) - } -} - -// It would be nice if this could be restricted to types implementing Widget. -// However, Widget (and AsyncWidget) have the E type parameter, which WidgetExt -// doesn't have. We sadly can't have unconstrained type parameters like that in -// impl blocks. -// -// If WidgetExt had a type parameter E, we'd need to specify that parameter -// everywhere we use the trait. This is less ergonomic than just constructing -// the types manually. -// -// Blanket-implementing this trait is not great, but usually works fine. -impl WidgetExt for W {} diff --git a/src/widgets.rs b/src/widgets.rs deleted file mode 100644 index cbbff7c..0000000 --- a/src/widgets.rs +++ /dev/null @@ -1,35 +0,0 @@ -pub mod background; -pub mod bell; -pub mod border; -pub mod boxed; -pub mod cursor; -pub mod desync; -pub mod editor; -pub mod either; -pub mod empty; -pub mod float; -pub mod join; -pub mod layer; -pub mod padding; -pub mod predrawn; -pub mod resize; -pub mod text; -pub mod title; - -pub use background::*; -pub use bell::*; -pub use border::*; -pub use boxed::*; -pub use cursor::*; -pub use desync::*; -pub use editor::*; -pub use either::*; -pub use empty::*; -pub use float::*; -pub use join::*; -pub use layer::*; -pub use padding::*; -pub use predrawn::*; -pub use resize::*; -pub use text::*; -pub use title::*; diff --git a/src/widgets/background.rs b/src/widgets/background.rs deleted file mode 100644 index d0ba530..0000000 --- a/src/widgets/background.rs +++ /dev/null @@ -1,71 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Pos, Size, Style, Widget, WidthDb}; - -#[derive(Debug, Clone, Copy)] -pub struct Background { - pub inner: I, - pub style: Style, -} - -impl Background { - pub fn new(inner: I) -> Self { - Self { - inner, - style: Style::new().opaque(), - } - } - - pub fn with_style(mut self, style: Style) -> Self { - self.style = style; - self - } - - fn fill(&self, frame: &mut Frame) { - let size = frame.size(); - for dy in 0..size.height { - for dx in 0..size.width { - frame.write(Pos::new(dx.into(), dy.into()), (" ", self.style)); - } - } - } -} - -impl Widget for Background -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.inner.size(widthdb, max_width, max_height) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.fill(frame); - self.inner.draw(frame) - } -} - -#[async_trait] -impl AsyncWidget for Background -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.inner.size(widthdb, max_width, max_height).await - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.fill(frame); - self.inner.draw(frame).await - } -} diff --git a/src/widgets/bell.rs b/src/widgets/bell.rs deleted file mode 100644 index b37fb67..0000000 --- a/src/widgets/bell.rs +++ /dev/null @@ -1,55 +0,0 @@ -use crate::{Frame, Size, Widget, WidthDb}; - -/////////// -// State // -/////////// - -#[derive(Debug, Default, Clone)] -pub struct BellState { - // Whether the bell should be rung the next time the widget is displayed. - pub ring: bool, -} - -impl BellState { - pub fn new() -> Self { - Self::default() - } - - pub fn widget(&mut self) -> Bell<'_> { - Bell { state: self } - } -} - -//////////// -// Widget // -//////////// - -#[derive(Debug)] -pub struct Bell<'a> { - state: &'a mut BellState, -} - -impl Bell<'_> { - pub fn state(&mut self) -> &mut BellState { - self.state - } -} - -impl Widget for Bell<'_> { - fn size( - &self, - _widthdb: &mut WidthDb, - _max_width: Option, - _max_height: Option, - ) -> Result { - Ok(Size::ZERO) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - if self.state.ring { - frame.set_bell(true); - self.state.ring = false - } - Ok(()) - } -} diff --git a/src/widgets/border.rs b/src/widgets/border.rs deleted file mode 100644 index 062cd8f..0000000 --- a/src/widgets/border.rs +++ /dev/null @@ -1,201 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Pos, Size, Style, Widget, WidthDb}; - -#[derive(Debug, Clone, Copy)] -pub struct BorderLook { - pub top_left: &'static str, - pub top_right: &'static str, - pub bottom_left: &'static str, - pub bottom_right: &'static str, - pub top: &'static str, - pub bottom: &'static str, - pub left: &'static str, - pub right: &'static str, -} - -impl BorderLook { - /// ```text - /// +-------+ - /// | Hello | - /// +-------+ - /// ``` - pub const ASCII: Self = Self { - top_left: "+", - top_right: "+", - bottom_left: "+", - bottom_right: "+", - top: "-", - bottom: "-", - left: "|", - right: "|", - }; - - /// ```text - /// ┌───────┐ - /// │ Hello │ - /// └───────┘ - /// ``` - pub const LINE: Self = Self { - top_left: "┌", - top_right: "┐", - bottom_left: "└", - bottom_right: "┘", - top: "─", - bottom: "─", - left: "│", - right: "│", - }; - - /// ```text - /// ┏━━━━━━━┓ - /// ┃ Hello ┃ - /// ┗━━━━━━━┛ - /// ``` - pub const LINE_HEAVY: Self = Self { - top_left: "┏", - top_right: "┓", - bottom_left: "┗", - bottom_right: "┛", - top: "━", - bottom: "━", - left: "┃", - right: "┃", - }; - - /// ```text - /// ╔═══════╗ - /// ║ Hello ║ - /// ╚═══════╝ - /// ``` - pub const LINE_DOUBLE: Self = Self { - top_left: "╔", - top_right: "╗", - bottom_left: "╚", - bottom_right: "╝", - top: "═", - bottom: "═", - left: "║", - right: "║", - }; -} - -impl Default for BorderLook { - fn default() -> Self { - Self::LINE - } -} - -#[derive(Debug, Clone, Copy)] -pub struct Border { - pub inner: I, - pub look: BorderLook, - pub style: Style, -} - -impl Border { - pub fn new(inner: I) -> Self { - Self { - inner, - look: BorderLook::default(), - style: Style::default(), - } - } - - pub fn with_look(mut self, look: BorderLook) -> Self { - self.look = look; - self - } - - pub fn with_style(mut self, style: Style) -> Self { - self.style = style; - self - } - - fn draw_border(&self, frame: &mut Frame) { - let size = frame.size(); - let right = size.width.saturating_sub(1).into(); - let bottom = size.height.saturating_sub(1).into(); - - for y in 1..bottom { - frame.write(Pos::new(right, y), (self.look.right, self.style)); - frame.write(Pos::new(0, y), (self.look.left, self.style)); - } - - for x in 1..right { - frame.write(Pos::new(x, bottom), (self.look.bottom, self.style)); - frame.write(Pos::new(x, 0), (self.look.top, self.style)); - } - - frame.write( - Pos::new(right, bottom), - (self.look.bottom_right, self.style), - ); - frame.write(Pos::new(0, bottom), (self.look.bottom_left, self.style)); - frame.write(Pos::new(right, 0), (self.look.top_right, self.style)); - frame.write(Pos::new(0, 0), (self.look.top_left, self.style)); - } - - fn push_inner(&self, frame: &mut Frame) { - let mut size = frame.size(); - size.width = size.width.saturating_sub(2); - size.height = size.height.saturating_sub(2); - - frame.push(Pos::new(1, 1), size); - } -} - -impl Widget for Border -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let max_width = max_width.map(|w| w.saturating_sub(2)); - let max_height = max_height.map(|h| h.saturating_sub(2)); - let size = self.inner.size(widthdb, max_width, max_height)?; - Ok(size + Size::new(2, 2)) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.draw_border(frame); - - self.push_inner(frame); - self.inner.draw(frame)?; - frame.pop(); - - Ok(()) - } -} - -#[async_trait] -impl AsyncWidget for Border -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let max_width = max_width.map(|w| w.saturating_sub(2)); - let max_height = max_height.map(|h| h.saturating_sub(2)); - let size = self.inner.size(widthdb, max_width, max_height).await?; - Ok(size + Size::new(2, 2)) - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.draw_border(frame); - - self.push_inner(frame); - self.inner.draw(frame).await?; - frame.pop(); - - Ok(()) - } -} diff --git a/src/widgets/boxed.rs b/src/widgets/boxed.rs deleted file mode 100644 index 3d9713f..0000000 --- a/src/widgets/boxed.rs +++ /dev/null @@ -1,142 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Size, Widget, WidthDb}; - -pub struct Boxed<'a, E>(Box + 'a>); - -impl<'a, E> Boxed<'a, E> { - pub fn new(inner: I) -> Self - where - I: Widget + 'a, - { - Self(Box::new(inner)) - } -} - -impl Widget for Boxed<'_, E> { - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.0.wrap_size(widthdb, max_width, max_height) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.0.wrap_draw(frame) - } -} - -pub struct BoxedSendSync<'a, E>(Box + Send + Sync + 'a>); - -impl<'a, E> BoxedSendSync<'a, E> { - pub fn new(inner: I) -> Self - where - I: Widget + Send + Sync + 'a, - { - Self(Box::new(inner)) - } -} - -impl Widget for BoxedSendSync<'_, E> { - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.0.wrap_size(widthdb, max_width, max_height) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.0.wrap_draw(frame) - } -} - -pub struct BoxedAsync<'a, E>(Box + Send + Sync + 'a>); - -impl<'a, E> BoxedAsync<'a, E> { - pub fn new(inner: I) -> Self - where - I: AsyncWidget + Send + Sync + 'a, - { - Self(Box::new(inner)) - } -} - -#[async_trait] -impl AsyncWidget for BoxedAsync<'_, E> { - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.0.wrap_size(widthdb, max_width, max_height).await - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.0.wrap_draw(frame).await - } -} - -trait WidgetWrapper { - fn wrap_size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result; - - fn wrap_draw(self: Box, frame: &mut Frame) -> Result<(), E>; -} - -impl WidgetWrapper for W -where - W: Widget, -{ - fn wrap_size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.size(widthdb, max_width, max_height) - } - - fn wrap_draw(self: Box, frame: &mut Frame) -> Result<(), E> { - (*self).draw(frame) - } -} - -#[async_trait] -trait AsyncWidgetWrapper { - async fn wrap_size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result; - - async fn wrap_draw(self: Box, frame: &mut Frame) -> Result<(), E>; -} - -#[async_trait] -impl AsyncWidgetWrapper for W -where - W: AsyncWidget + Send + Sync, -{ - async fn wrap_size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.size(widthdb, max_width, max_height).await - } - - async fn wrap_draw(self: Box, frame: &mut Frame) -> Result<(), E> { - (*self).draw(frame).await - } -} diff --git a/src/widgets/cursor.rs b/src/widgets/cursor.rs deleted file mode 100644 index 2bb8199..0000000 --- a/src/widgets/cursor.rs +++ /dev/null @@ -1,68 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Pos, Size, Widget, WidthDb}; - -#[derive(Debug, Clone, Copy)] -pub struct Cursor { - pub inner: I, - pub position: Pos, -} - -impl Cursor { - pub fn new(inner: I) -> Self { - Self { - inner, - position: Pos::ZERO, - } - } - - pub fn with_position(mut self, position: Pos) -> Self { - self.position = position; - self - } - - pub fn with_position_xy(self, x: i32, y: i32) -> Self { - self.with_position(Pos::new(x, y)) - } -} - -impl Widget for Cursor -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.inner.size(widthdb, max_width, max_height) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.inner.draw(frame)?; - frame.show_cursor(self.position); - Ok(()) - } -} - -#[async_trait] -impl AsyncWidget for Cursor -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.inner.size(widthdb, max_width, max_height).await - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.inner.draw(frame).await?; - frame.show_cursor(self.position); - Ok(()) - } -} diff --git a/src/widgets/desync.rs b/src/widgets/desync.rs deleted file mode 100644 index 67e7488..0000000 --- a/src/widgets/desync.rs +++ /dev/null @@ -1,42 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Widget}; - -pub struct Desync(pub I); - -impl Widget for Desync -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut crate::WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.0.size(widthdb, max_width, max_height) - } - - fn draw(self, frame: &mut crate::Frame) -> Result<(), E> { - self.0.draw(frame) - } -} - -#[async_trait] -impl AsyncWidget for Desync -where - I: Widget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut crate::WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.0.size(widthdb, max_width, max_height) - } - - async fn draw(self, frame: &mut crate::Frame) -> Result<(), E> { - self.0.draw(frame) - } -} diff --git a/src/widgets/editor.rs b/src/widgets/editor.rs deleted file mode 100644 index aa36e8e..0000000 --- a/src/widgets/editor.rs +++ /dev/null @@ -1,485 +0,0 @@ -use std::iter; - -use crossterm::style::Stylize; -use unicode_segmentation::UnicodeSegmentation; - -use crate::{Frame, Pos, Size, Style, Styled, Widget, WidthDb}; - -/// Like [`WidthDb::wrap`] but includes a final break index if the text ends -/// with a newline. -fn wrap(widthdb: &mut WidthDb, text: &str, width: usize) -> Vec { - let mut breaks = widthdb.wrap(text, width); - if text.ends_with('\n') { - breaks.push(text.len()) - } - breaks -} - -/////////// -// State // -/////////// - -#[derive(Debug, Clone)] -pub struct EditorState { - text: String, - - /// Index of the cursor in the text. - /// - /// Must point to a valid grapheme boundary. - cursor_idx: usize, - - /// Column of the cursor on the screen just after it was last moved - /// horizontally. - cursor_col: usize, - - /// Position of the cursor when the editor was last rendered. - last_cursor_pos: Pos, -} - -impl EditorState { - pub fn new() -> Self { - Self::with_initial_text(String::new()) - } - - pub fn with_initial_text(text: String) -> Self { - Self { - cursor_idx: text.len(), - cursor_col: 0, - last_cursor_pos: Pos::ZERO, - text, - } - } - - /////////////////////////////// - // Grapheme helper functions // - /////////////////////////////// - - fn grapheme_boundaries(&self) -> Vec { - self.text - .grapheme_indices(true) - .map(|(i, _)| i) - .chain(iter::once(self.text.len())) - .collect() - } - - /// Ensure the cursor index lies on a grapheme boundary. If it doesn't, it - /// is moved to the next grapheme boundary. - /// - /// Can handle arbitrary cursor index. - fn move_cursor_to_grapheme_boundary(&mut self) { - for i in self.grapheme_boundaries() { - #[allow(clippy::comparison_chain)] - if i == self.cursor_idx { - // We're at a valid grapheme boundary already - return; - } else if i > self.cursor_idx { - // There was no valid grapheme boundary at our cursor index, so - // we'll take the next one we can get. - self.cursor_idx = i; - return; - } - } - - // The cursor was out of bounds, so move it to the last valid index. - self.cursor_idx = self.text.len(); - } - - /////////////////////////////// - // Line/col helper functions // - /////////////////////////////// - - /// Like [`Self::grapheme_boundaries`] but for lines. - /// - /// Note that the last line can have a length of 0 if the text ends with a - /// newline. - fn line_boundaries(&self) -> Vec { - let newlines = self - .text - .char_indices() - .filter(|(_, c)| *c == '\n') - .map(|(i, _)| i + 1); // utf-8 encodes '\n' as a single byte - iter::once(0) - .chain(newlines) - .chain(iter::once(self.text.len())) - .collect() - } - - /// Find the cursor's current line. - /// - /// Returns `(line_nr, start_idx, end_idx)`. - fn cursor_line(&self, boundaries: &[usize]) -> (usize, usize, usize) { - let mut result = (0, 0, 0); - for (i, (start, end)) in boundaries.iter().zip(boundaries.iter().skip(1)).enumerate() { - if self.cursor_idx >= *start { - result = (i, *start, *end); - } else { - break; - } - } - result - } - - fn cursor_col(&self, widthdb: &mut WidthDb, line_start: usize) -> usize { - widthdb.width(&self.text[line_start..self.cursor_idx]) - } - - fn line(&self, line: usize) -> (usize, usize) { - let boundaries = self.line_boundaries(); - boundaries - .iter() - .copied() - .zip(boundaries.iter().copied().skip(1)) - .nth(line) - .expect("line exists") - } - - fn move_cursor_to_line_col(&mut self, widthdb: &mut WidthDb, line: usize, col: usize) { - let (start, end) = self.line(line); - let line = &self.text[start..end]; - - let mut width = 0; - for (gi, g) in line.grapheme_indices(true) { - self.cursor_idx = start + gi; - if col > width { - width += widthdb.grapheme_width(g, width) as usize; - } else { - return; - } - } - - if !line.ends_with('\n') { - self.cursor_idx = end; - } - } - - fn record_cursor_col(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.line_boundaries(); - let (_, start, _) = self.cursor_line(&boundaries); - self.cursor_col = self.cursor_col(widthdb, start); - } - - ///////////// - // Editing // - ///////////// - - pub fn text(&self) -> &str { - &self.text - } - - pub fn set_text(&mut self, widthdb: &mut WidthDb, text: String) { - self.text = text; - self.move_cursor_to_grapheme_boundary(); - self.record_cursor_col(widthdb); - } - - pub fn clear(&mut self) { - self.text = String::new(); - self.cursor_idx = 0; - self.cursor_col = 0; - } - - /// Insert a character at the current cursor position and move the cursor - /// accordingly. - pub fn insert_char(&mut self, widthdb: &mut WidthDb, ch: char) { - self.text.insert(self.cursor_idx, ch); - self.cursor_idx += ch.len_utf8(); - self.record_cursor_col(widthdb); - } - - /// Insert a string at the current cursor position and move the cursor - /// accordingly. - pub fn insert_str(&mut self, widthdb: &mut WidthDb, str: &str) { - self.text.insert_str(self.cursor_idx, str); - self.cursor_idx += str.len(); - self.record_cursor_col(widthdb); - } - - /// Delete the grapheme before the cursor position. - pub fn backspace(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.grapheme_boundaries(); - for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) { - if *end == self.cursor_idx { - self.text.replace_range(start..end, ""); - self.cursor_idx = *start; - self.record_cursor_col(widthdb); - break; - } - } - } - - /// Delete the grapheme after the cursor position. - pub fn delete(&mut self) { - let boundaries = self.grapheme_boundaries(); - for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) { - if *start == self.cursor_idx { - self.text.replace_range(start..end, ""); - break; - } - } - } - - ///////////////////// - // Cursor movement // - ///////////////////// - - pub fn move_cursor_left(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.grapheme_boundaries(); - for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) { - if *end == self.cursor_idx { - self.cursor_idx = *start; - self.record_cursor_col(widthdb); - break; - } - } - } - - pub fn move_cursor_right(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.grapheme_boundaries(); - for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) { - if *start == self.cursor_idx { - self.cursor_idx = *end; - self.record_cursor_col(widthdb); - break; - } - } - } - - pub fn move_cursor_left_a_word(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.grapheme_boundaries(); - let mut encountered_word = false; - for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)).rev() { - if *end == self.cursor_idx { - let g = &self.text[*start..*end]; - let whitespace = g.chars().all(|c| c.is_whitespace()); - if encountered_word && whitespace { - break; - } else if !whitespace { - encountered_word = true; - } - self.cursor_idx = *start; - } - } - self.record_cursor_col(widthdb); - } - - pub fn move_cursor_right_a_word(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.grapheme_boundaries(); - let mut encountered_word = false; - for (start, end) in boundaries.iter().zip(boundaries.iter().skip(1)) { - if *start == self.cursor_idx { - let g = &self.text[*start..*end]; - let whitespace = g.chars().all(|c| c.is_whitespace()); - if encountered_word && whitespace { - break; - } else if !whitespace { - encountered_word = true; - } - self.cursor_idx = *end; - } - } - self.record_cursor_col(widthdb); - } - - pub fn move_cursor_to_start_of_line(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.line_boundaries(); - let (line, _, _) = self.cursor_line(&boundaries); - self.move_cursor_to_line_col(widthdb, line, 0); - self.record_cursor_col(widthdb); - } - - pub fn move_cursor_to_end_of_line(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.line_boundaries(); - let (line, _, _) = self.cursor_line(&boundaries); - self.move_cursor_to_line_col(widthdb, line, usize::MAX); - self.record_cursor_col(widthdb); - } - - pub fn move_cursor_up(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.line_boundaries(); - let (line, _, _) = self.cursor_line(&boundaries); - if line > 0 { - self.move_cursor_to_line_col(widthdb, line - 1, self.cursor_col); - } - } - - pub fn move_cursor_down(&mut self, widthdb: &mut WidthDb) { - let boundaries = self.line_boundaries(); - - // There's always at least one line, and always at least two line - // boundaries at 0 and self.text.len(). - let amount_of_lines = boundaries.len() - 1; - - let (line, _, _) = self.cursor_line(&boundaries); - if line + 1 < amount_of_lines { - self.move_cursor_to_line_col(widthdb, line + 1, self.cursor_col); - } - } - - pub fn last_cursor_pos(&self) -> Pos { - self.last_cursor_pos - } - - pub fn widget(&mut self) -> Editor<'_> { - Editor { - highlighted: Styled::new_plain(&self.text), - hidden: None, - focus: true, - state: self, - } - } -} - -impl Default for EditorState { - fn default() -> Self { - Self::new() - } -} - -//////////// -// Widget // -//////////// - -#[derive(Debug)] -pub struct Editor<'a> { - state: &'a mut EditorState, - highlighted: Styled, - pub hidden: Option, - pub focus: bool, -} - -impl Editor<'_> { - pub fn state(&mut self) -> &mut EditorState { - self.state - } - - pub fn text(&self) -> &Styled { - &self.highlighted - } - - pub fn highlight(&mut self, highlight: F) - where - F: FnOnce(&str) -> Styled, - { - self.highlighted = highlight(&self.state.text); - assert_eq!(self.state.text, self.highlighted.text()); - } - - pub fn with_highlight(mut self, highlight: F) -> Self - where - F: FnOnce(&str) -> Styled, - { - self.highlight(highlight); - self - } - - pub fn with_visible(mut self) -> Self { - self.hidden = None; - self - } - - pub fn with_hidden>(mut self, placeholder: S) -> Self { - self.hidden = Some(placeholder.into()); - self - } - - pub fn with_hidden_default_placeholder(self) -> Self { - self.with_hidden(("", Style::new().grey().italic())) - } - - pub fn with_focus(mut self, active: bool) -> Self { - self.focus = active; - self - } - - fn wrapped_cursor(cursor_idx: usize, break_indices: &[usize]) -> (usize, usize) { - let mut row = 0; - let mut line_idx = cursor_idx; - - for break_idx in break_indices { - if cursor_idx < *break_idx { - break; - } else { - row += 1; - line_idx = cursor_idx - break_idx; - } - } - - (row, line_idx) - } - - fn indices(&self, widthdb: &mut WidthDb, max_width: Option) -> Vec { - let max_width = max_width - // One extra column for cursor - .map(|w| w.saturating_sub(1) as usize) - .unwrap_or(usize::MAX); - let text = self.hidden.as_ref().unwrap_or(&self.highlighted); - wrap(widthdb, text.text(), max_width) - } - - fn rows(&self, indices: &[usize]) -> Vec { - let text = match self.hidden.as_ref() { - Some(hidden) if !self.highlighted.text().is_empty() => hidden, - _ => &self.highlighted, - }; - text.clone().split_at_indices(indices) - } - - fn cursor(&self, widthdb: &mut WidthDb, width: u16, indices: &[usize], rows: &[Styled]) -> Pos { - if self.hidden.is_some() { - return Pos::new(0, 0); - } - - let (cursor_row, cursor_line_idx) = Self::wrapped_cursor(self.state.cursor_idx, indices); - let cursor_col = widthdb.width(rows[cursor_row].text().split_at(cursor_line_idx).0); - - // Ensure the cursor is always visible - let cursor_col = cursor_col.min(width.saturating_sub(1).into()); - - let cursor_row: i32 = cursor_row.try_into().unwrap_or(i32::MAX); - let cursor_col: i32 = cursor_col.try_into().unwrap_or(i32::MAX); - Pos::new(cursor_col, cursor_row) - } -} - -impl Widget for Editor<'_> { - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - _max_height: Option, - ) -> Result { - let indices = self.indices(widthdb, max_width); - let rows = self.rows(&indices); - - let width = rows - .iter() - .map(|row| widthdb.width(row.text())) - .max() - .unwrap_or(0) - // One extra column for cursor - .saturating_add(1); - let height = rows.len(); - - let width: u16 = width.try_into().unwrap_or(u16::MAX); - let height: u16 = height.try_into().unwrap_or(u16::MAX); - Ok(Size::new(width, height)) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - let size = frame.size(); - let indices = self.indices(frame.widthdb(), Some(size.width)); - let rows = self.rows(&indices); - let cursor = self.cursor(frame.widthdb(), size.width, &indices, &rows); - - for (i, row) in rows.into_iter().enumerate() { - frame.write(Pos::new(0, i as i32), row); - } - - if self.focus { - frame.set_cursor(Some(cursor)); - } - self.state.last_cursor_pos = cursor; - - Ok(()) - } -} diff --git a/src/widgets/either.rs b/src/widgets/either.rs deleted file mode 100644 index cb9a55d..0000000 --- a/src/widgets/either.rs +++ /dev/null @@ -1,118 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Size, Widget, WidthDb}; - -macro_rules! mk_either { - ( - pub enum $name:ident { - $( $constr:ident($ty:ident), )+ - } - ) => { - #[derive(Debug, Clone, Copy)] - pub enum $name< $( $ty ),+ > { - $( $constr($ty), )+ - } - - impl Widget for $name< $( $ty ),+ > - where - $( $ty: Widget, )+ - { - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - match self { - $( Self::$constr(w) => w.size(widthdb, max_width, max_height), )+ - } - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - match self { - $( Self::$constr(w) => w.draw(frame), )+ - } - } - } - - #[async_trait] - impl AsyncWidget for $name< $( $ty ),+ > - where - $( $ty: AsyncWidget + Send + Sync, )+ - { - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - match self { - $( Self::$constr(w) => w.size(widthdb, max_width, max_height).await, )+ - } - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - match self { - $( Self::$constr(w) => w.draw(frame).await, )+ - } - } - } - }; -} - -mk_either! { - pub enum Either2 { - First(I1), - Second(I2), - } -} - -mk_either! { - pub enum Either3 { - First(I1), - Second(I2), - Third(I3), - } -} - -mk_either! { - pub enum Either4 { - First(I1), - Second(I2), - Third(I3), - Fourth(I4), - } -} - -mk_either! { - pub enum Either5 { - First(I1), - Second(I2), - Third(I3), - Fourth(I4), - Fifth(I5), - } -} - -mk_either! { - pub enum Either6 { - First(I1), - Second(I2), - Third(I3), - Fourth(I4), - Fifth(I5), - Sixth(I6), - } -} - -mk_either! { - pub enum Either7 { - First(I1), - Second(I2), - Third(I3), - Fourth(I4), - Fifth(I5), - Sixth(I6), - Seventh(I7), - } -} diff --git a/src/widgets/empty.rs b/src/widgets/empty.rs deleted file mode 100644 index 5de4fdf..0000000 --- a/src/widgets/empty.rs +++ /dev/null @@ -1,42 +0,0 @@ -use crate::{Frame, Size, Widget, WidthDb}; - -#[derive(Debug, Default, Clone, Copy)] -pub struct Empty { - pub size: Size, -} - -impl Empty { - pub fn new() -> Self { - Self { size: Size::ZERO } - } - - pub fn with_width(mut self, width: u16) -> Self { - self.size.width = width; - self - } - - pub fn with_height(mut self, height: u16) -> Self { - self.size.height = height; - self - } - - pub fn with_size(mut self, size: Size) -> Self { - self.size = size; - self - } -} - -impl Widget for Empty { - fn size( - &self, - _widthdb: &mut WidthDb, - _max_width: Option, - _max_height: Option, - ) -> Result { - Ok(self.size) - } - - fn draw(self, _frame: &mut Frame) -> Result<(), E> { - Ok(()) - } -} diff --git a/src/widgets/float.rs b/src/widgets/float.rs deleted file mode 100644 index 5cfb349..0000000 --- a/src/widgets/float.rs +++ /dev/null @@ -1,166 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Pos, Size, Widget, WidthDb}; - -#[derive(Debug, Clone, Copy)] -pub struct Float { - pub inner: I, - horizontal: Option, - vertical: Option, -} - -impl Float { - pub fn new(inner: I) -> Self { - Self { - inner, - horizontal: None, - vertical: None, - } - } - - pub fn horizontal(&self) -> Option { - self.horizontal - } - - pub fn set_horizontal(&mut self, position: Option) { - if let Some(position) = position { - assert!((0.0..=1.0).contains(&position)); - } - self.horizontal = position; - } - - pub fn vertical(&self) -> Option { - self.vertical - } - - pub fn set_vertical(&mut self, position: Option) { - if let Some(position) = position { - assert!((0.0..=1.0).contains(&position)); - } - self.vertical = position; - } - - pub fn with_horizontal(mut self, position: f32) -> Self { - self.set_horizontal(Some(position)); - self - } - - pub fn with_vertical(mut self, position: f32) -> Self { - self.set_vertical(Some(position)); - self - } - - pub fn with_all(self, position: f32) -> Self { - self.with_horizontal(position).with_vertical(position) - } - - pub fn with_left(self) -> Self { - self.with_horizontal(0.0) - } - - pub fn with_right(self) -> Self { - self.with_horizontal(1.0) - } - - pub fn with_top(self) -> Self { - self.with_vertical(0.0) - } - - pub fn with_bottom(self) -> Self { - self.with_vertical(1.0) - } - - pub fn with_center_h(self) -> Self { - self.with_horizontal(0.5) - } - - pub fn with_center_v(self) -> Self { - self.with_vertical(0.5) - } - - pub fn with_center(self) -> Self { - self.with_all(0.5) - } - - fn push_inner(&self, frame: &mut Frame, size: Size, mut inner_size: Size) { - let mut inner_pos = Pos::ZERO; - - if let Some(horizontal) = self.horizontal { - let available = size.width.saturating_sub(inner_size.width) as f32; - // Biased towards the left if horizontal lands exactly on the - // boundary between two cells - inner_pos.x = (horizontal * available).floor().min(available) as i32; - inner_size.width = inner_size.width.min(size.width); - } else { - inner_size.width = size.width; - } - - if let Some(vertical) = self.vertical { - let available = size.height.saturating_sub(inner_size.height) as f32; - // Biased towards the top if vertical lands exactly on the boundary - // between two cells - inner_pos.y = (vertical * available).floor().min(available) as i32; - inner_size.height = inner_size.height.min(size.height); - } else { - inner_size.height = size.height; - } - - frame.push(inner_pos, inner_size); - } -} - -impl Widget for Float -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.inner.size(widthdb, max_width, max_height) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - let size = frame.size(); - let inner_size = self - .inner - .size(frame.widthdb(), Some(size.width), Some(size.height))?; - - self.push_inner(frame, size, inner_size); - self.inner.draw(frame)?; - frame.pop(); - - Ok(()) - } -} - -#[async_trait] -impl AsyncWidget for Float -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.inner.size(widthdb, max_width, max_height).await - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - let size = frame.size(); - let inner_size = self - .inner - .size(frame.widthdb(), Some(size.width), Some(size.height)) - .await?; - - self.push_inner(frame, size, inner_size); - self.inner.draw(frame).await?; - frame.pop(); - - Ok(()) - } -} diff --git a/src/widgets/join.rs b/src/widgets/join.rs deleted file mode 100644 index 20cd413..0000000 --- a/src/widgets/join.rs +++ /dev/null @@ -1,721 +0,0 @@ -use std::cmp::Ordering; - -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Pos, Size, Widget, WidthDb}; - -// The following algorithm has three goals, listed in order of importance: -// -// 1. Use the available space -// 2. Avoid shrinking segments where possible -// 3. Match the given weights as closely as possible -// -// Its input is a list of weighted segments where each segment wants to use a -// certain amount of space. The weights signify how the available space would be -// assigned if goal 2 was irrelevant. -// -// First, the algorithm must decide whether it must grow or shrink segments. -// Because goal 2 has a higher priority than goal 3, it never makes sense to -// shrink a segment in order to make another larger. In both cases, a segment's -// actual size is compared to its allotment, i. e. what size it should be based -// on its weight. -// -// Growth -// ====== -// -// If segments must be grown, an important observation can be made: If all -// segments are smaller than their allotment, then each segment can be assigned -// its allotment without violating goal 2, thereby fulfilling goal 3. -// -// Another important observation can be made: If a segment is at least as large -// as its allotment, it must never be grown as that would violate goal 3. -// -// Based on these two observations, the growth algorithm first repeatedly -// removes all segments that are at least as large as their allotment. It then -// resizes the remaining segments to their allotments. -// -// Shrinkage -// ========= -// -// If segments must be shrunk, an important observation can be made: If all -// segments are larger than their allotment, then each segment can be assigned -// its allotment, thereby fulfilling goal 3. Since goal 1 is more important than -// goal 2, we know that some elements must be shrunk. -// -// Another important observation can be made: If a segment is at least as small -// as its allotment, it must never be shrunk as that would violate goal 3. -// -// Based on these two observations, the shrinkage algorithm first repeatedly -// removes all segments that are at least as small as their allotment. It then -// resizes the remaining segments to their allotments. - -#[derive(Debug)] -struct Segment { - major: u16, - minor: u16, - weight: f32, - growing: bool, - shrinking: bool, -} - -impl Segment { - fn new(major_minor: (u16, u16), segment: &JoinSegment) -> Self { - Self { - major: major_minor.0, - minor: major_minor.1, - weight: segment.weight, - growing: segment.growing, - shrinking: segment.shrinking, - } - } -} - -fn total_size(segments: &[&mut Segment]) -> u16 { - let mut total = 0_u16; - for segment in segments { - total = total.saturating_add(segment.major); - } - total -} - -fn total_weight(segments: &[&mut Segment]) -> f32 { - segments.iter().map(|s| s.weight).sum() -} - -fn balance(segments: &mut [Segment], available: u16) { - let segments = segments.iter_mut().collect::>(); - match total_size(&segments).cmp(&available) { - Ordering::Less => grow(segments, available), - Ordering::Greater => shrink(segments, available), - Ordering::Equal => {} - } -} - -fn grow(mut segments: Vec<&mut Segment>, mut available: u16) { - assert!(available >= total_size(&segments)); - - // Only grow segments that can be grown. - segments.retain(|s| { - if s.growing { - return true; - } - available = available.saturating_sub(s.major); - false - }); - - // Repeatedly remove all segments that do not need to grow, i. e. that are - // at least as large as their allotment. - loop { - let mut total_weight = total_weight(&segments); - - // If there are no segments with a weight > 0, space is distributed - // evenly among all remaining segments. - if total_weight <= 0.0 { - for segment in &mut segments { - segment.weight = 1.0; - } - total_weight = segments.len() as f32; - } - - let mut removed = 0; - segments.retain(|s| { - let allotment = s.weight / total_weight * available as f32; - if (s.major as f32) < allotment { - return true; // May need to grow - } - removed += s.major; - false - }); - available -= removed; - - if removed == 0 { - break; // All remaining segments are smaller than their allotments - } - } - - let total_weight = segments.iter().map(|s| s.weight).sum::(); - if total_weight <= 0.0 { - return; // No more segments left - } - - // Size each remaining segment according to its allotment. - let mut used = 0; - for segment in &mut segments { - let allotment = segment.weight / total_weight * available as f32; - segment.major = allotment.floor() as u16; - used += segment.major; - } - - // Distribute remaining unused space from left to right. - // - // The rounding error on each segment is at most 1, so we only need to loop - // over the segments once. - let remaining = available - used; - assert!(remaining as usize <= segments.len()); - for segment in segments.into_iter().take(remaining.into()) { - segment.major += 1; - } -} - -fn shrink(mut segments: Vec<&mut Segment>, mut available: u16) { - assert!(available <= total_size(&segments)); - - // Only shrink segments that can be shrunk. - segments.retain(|s| { - if s.shrinking { - return true; - } - available = available.saturating_sub(s.major); - false - }); - - // Repeatedly remove all segments that do not need to shrink, i. e. that are - // at least as small as their allotment. - loop { - let mut total_weight = total_weight(&segments); - - // If there are no segments with a weight > 0, space is distributed - // evenly among all remaining segments. - if total_weight <= 0.0 { - for segment in &mut segments { - segment.weight = 1.0; - } - total_weight = segments.len() as f32; - } - - let mut removed = 0; - segments.retain(|s| { - let allotment = s.weight / total_weight * available as f32; - if (s.major as f32) > allotment { - return true; // May need to shrink - } - - // The segment size subtracted from `available` is always smaller - // than or equal to its allotment. Since `available` is the sum of - // all allotments, it can never go below 0. - assert!(s.major <= available); - - removed += s.major; - false - }); - available -= removed; - - if removed == 0 { - break; // All segments want more than their weight allows. - } - } - - let total_weight = segments.iter().map(|s| s.weight).sum::(); - if total_weight <= 0.0 { - return; // No more segments left - } - - // Size each remaining segment according to its allotment. - let mut used = 0; - for segment in &mut segments { - let allotment = segment.weight / total_weight * available as f32; - segment.major = allotment.floor() as u16; - used += segment.major; - } - - // Distribute remaining unused space from left to right. - // - // The rounding error on each segment is at most 1, so we only need to loop - // over the segments once. - let remaining = available - used; - assert!(remaining as usize <= segments.len()); - for segment in segments.into_iter().take(remaining.into()) { - segment.major += 1; - } -} - -#[derive(Debug, Clone, Copy)] -pub struct JoinSegment { - pub inner: I, - weight: f32, - pub growing: bool, - pub shrinking: bool, -} - -impl JoinSegment { - pub fn new(inner: I) -> Self { - Self { - inner, - weight: 1.0, - growing: true, - shrinking: true, - } - } - - pub fn weight(&self) -> f32 { - self.weight - } - - pub fn set_weight(&mut self, weight: f32) { - assert!(weight >= 0.0); - self.weight = weight; - } - - pub fn with_weight(mut self, weight: f32) -> Self { - self.set_weight(weight); - self - } - - pub fn with_growing(mut self, enabled: bool) -> Self { - self.growing = enabled; - self - } - - pub fn with_shrinking(mut self, enabled: bool) -> Self { - self.shrinking = enabled; - self - } - - pub fn with_fixed(self, fixed: bool) -> Self { - self.with_growing(!fixed).with_shrinking(!fixed) - } -} - -fn to_mm(horizontal: bool, w: T, h: T) -> (T, T) { - if horizontal { - (w, h) - } else { - (h, w) - } -} - -fn from_mm(horizontal: bool, major: T, minor: T) -> (T, T) { - if horizontal { - (major, minor) - } else { - (minor, major) - } -} - -fn size>( - horizontal: bool, - widthdb: &mut WidthDb, - segment: &JoinSegment, - major: Option, - minor: Option, -) -> Result<(u16, u16), E> { - if horizontal { - let size = segment.inner.size(widthdb, major, minor)?; - Ok((size.width, size.height)) - } else { - let size = segment.inner.size(widthdb, minor, major)?; - Ok((size.height, size.width)) - } -} - -fn size_with_balanced>( - horizontal: bool, - widthdb: &mut WidthDb, - segment: &JoinSegment, - balanced: &Segment, - minor: Option, -) -> Result<(u16, u16), E> { - size(horizontal, widthdb, segment, Some(balanced.major), minor) -} - -async fn size_async>( - horizontal: bool, - widthdb: &mut WidthDb, - segment: &JoinSegment, - major: Option, - minor: Option, -) -> Result<(u16, u16), E> { - if horizontal { - let size = segment.inner.size(widthdb, major, minor).await?; - Ok((size.width, size.height)) - } else { - let size = segment.inner.size(widthdb, minor, major).await?; - Ok((size.height, size.width)) - } -} - -async fn size_async_with_balanced>( - horizontal: bool, - widthdb: &mut WidthDb, - segment: &JoinSegment, - balanced: &Segment, - minor: Option, -) -> Result<(u16, u16), E> { - size_async(horizontal, widthdb, segment, Some(balanced.major), minor).await -} - -fn sum_major_max_minor(segments: &[Segment]) -> (u16, u16) { - let mut major = 0_u16; - let mut minor = 0_u16; - for segment in segments { - major = major.saturating_add(segment.major); - minor = minor.max(segment.minor); - } - (major, minor) -} - -#[derive(Debug, Clone)] -pub struct Join { - horizontal: bool, - segments: Vec>, -} - -impl Join { - pub fn horizontal(segments: Vec>) -> Self { - Self { - horizontal: true, - segments, - } - } - - pub fn vertical(segments: Vec>) -> Self { - Self { - horizontal: false, - segments, - } - } -} - -impl Widget for Join -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let (max_major, max_minor) = to_mm(self.horizontal, max_width, max_height); - - let mut segments = Vec::with_capacity(self.segments.len()); - for segment in &self.segments { - let major_minor = size(self.horizontal, widthdb, segment, None, max_minor)?; - segments.push(Segment::new(major_minor, segment)); - } - - if let Some(available) = max_major { - balance(&mut segments, available); - - let mut new_segments = Vec::with_capacity(self.segments.len()); - for (segment, balanced) in self.segments.iter().zip(segments.into_iter()) { - let major_minor = - size_with_balanced(self.horizontal, widthdb, segment, &balanced, max_minor)?; - new_segments.push(Segment::new(major_minor, segment)); - } - segments = new_segments; - } - - let (major, minor) = sum_major_max_minor(&segments); - let (width, height) = from_mm(self.horizontal, major, minor); - Ok(Size::new(width, height)) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - let frame_size = frame.size(); - let (max_major, max_minor) = to_mm(self.horizontal, frame_size.width, frame_size.height); - - let widthdb = frame.widthdb(); - let mut segments = Vec::with_capacity(self.segments.len()); - for segment in &self.segments { - let major_minor = size(self.horizontal, widthdb, segment, None, Some(max_minor))?; - segments.push(Segment::new(major_minor, segment)); - } - balance(&mut segments, max_major); - - let mut major = 0_i32; - for (segment, balanced) in self.segments.into_iter().zip(segments.into_iter()) { - let (x, y) = from_mm(self.horizontal, major, 0); - let (w, h) = from_mm(self.horizontal, balanced.major, max_minor); - frame.push(Pos::new(x, y), Size::new(w, h)); - segment.inner.draw(frame)?; - frame.pop(); - major += balanced.major as i32; - } - - Ok(()) - } -} - -#[async_trait] -impl AsyncWidget for Join -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let (max_major, max_minor) = to_mm(self.horizontal, max_width, max_height); - - let mut segments = Vec::with_capacity(self.segments.len()); - for segment in &self.segments { - let major_minor = - size_async(self.horizontal, widthdb, segment, None, max_minor).await?; - segments.push(Segment::new(major_minor, segment)); - } - - if let Some(available) = max_major { - balance(&mut segments, available); - - let mut new_segments = Vec::with_capacity(self.segments.len()); - for (segment, balanced) in self.segments.iter().zip(segments.into_iter()) { - let major_minor = size_async_with_balanced( - self.horizontal, - widthdb, - segment, - &balanced, - max_minor, - ) - .await?; - new_segments.push(Segment::new(major_minor, segment)); - } - segments = new_segments; - } - - let (major, minor) = sum_major_max_minor(&segments); - let (width, height) = from_mm(self.horizontal, major, minor); - Ok(Size::new(width, height)) - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - let frame_size = frame.size(); - let (max_major, max_minor) = to_mm(self.horizontal, frame_size.width, frame_size.height); - - let widthdb = frame.widthdb(); - let mut segments = Vec::with_capacity(self.segments.len()); - for segment in &self.segments { - let major_minor = - size_async(self.horizontal, widthdb, segment, None, Some(max_minor)).await?; - segments.push(Segment::new(major_minor, segment)); - } - balance(&mut segments, max_major); - - let mut major = 0_i32; - for (segment, balanced) in self.segments.into_iter().zip(segments.into_iter()) { - let (x, y) = from_mm(self.horizontal, major, 0); - let (w, h) = from_mm(self.horizontal, balanced.major, max_minor); - frame.push(Pos::new(x, y), Size::new(w, h)); - segment.inner.draw(frame).await?; - frame.pop(); - major += balanced.major as i32; - } - - Ok(()) - } -} - -macro_rules! mk_join { - ( - pub struct $name:ident { - $( pub $arg:ident: $type:ident [$n:expr], )+ - } - ) => { - #[derive(Debug, Clone, Copy)] - pub struct $name< $($type),+ >{ - horizontal: bool, - $( pub $arg: JoinSegment<$type>, )+ - } - - impl< $($type),+ > $name< $($type),+ >{ - pub fn horizontal( $($arg: JoinSegment<$type>),+ ) -> Self { - Self { horizontal: true, $( $arg, )+ } - } - - pub fn vertical( $($arg: JoinSegment<$type>),+ ) -> Self { - Self { horizontal: false, $( $arg, )+ } - } - } - - impl Widget for $name< $($type),+ > - where - $( $type: Widget, )+ - { - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let (max_major, max_minor) = to_mm(self.horizontal, max_width, max_height); - - let mut segments = [ $( - Segment::new( - size(self.horizontal, widthdb, &self.$arg, None, max_minor)?, - &self.$arg, - ), - )+ ]; - - if let Some(available) = max_major { - balance(&mut segments, available); - - let new_segments = [ $( - Segment::new( - size_with_balanced(self.horizontal, widthdb, &self.$arg, &segments[$n], max_minor)?, - &self.$arg, - ), - )+ ]; - segments = new_segments; - } - - let (major, minor) = sum_major_max_minor(&segments); - let (width, height) = from_mm(self.horizontal, major, minor); - Ok(Size::new(width, height)) - } - - #[allow(unused_assignments)] - fn draw(self, frame: &mut Frame) -> Result<(), E> { - let frame_size = frame.size(); - let (max_major, max_minor) = to_mm(self.horizontal, frame_size.width, frame_size.height); - - let widthdb = frame.widthdb(); - let mut segments = [ $( - Segment::new( - size(self.horizontal, widthdb, &self.$arg, None, Some(max_minor))?, - &self.$arg, - ), - )+ ]; - balance(&mut segments, max_major); - - let mut major = 0_i32; - $( { - let balanced = &segments[$n]; - let (x, y) = from_mm(self.horizontal, major, 0); - let (w, h) = from_mm(self.horizontal, balanced.major, max_minor); - frame.push(Pos::new(x, y), Size::new(w, h)); - self.$arg.inner.draw(frame)?; - frame.pop(); - major += balanced.major as i32; - } )* - - Ok(()) - } - } - - #[async_trait] - impl AsyncWidget for $name< $($type),+ > - where - E: Send, - $( $type: AsyncWidget + Send + Sync, )+ - { - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let (max_major, max_minor) = to_mm(self.horizontal, max_width, max_height); - - let mut segments = [ $( - Segment::new( - size_async(self.horizontal, widthdb, &self.$arg, None, max_minor).await?, - &self.$arg, - ), - )+ ]; - - if let Some(available) = max_major { - balance(&mut segments, available); - - let new_segments = [ $( - Segment::new( - size_async_with_balanced(self.horizontal, widthdb, &self.$arg, &segments[$n], max_minor).await?, - &self.$arg, - ), - )+ ]; - segments = new_segments; - } - - let (major, minor) = sum_major_max_minor(&segments); - let (width, height) = from_mm(self.horizontal, major, minor); - Ok(Size::new(width, height)) - } - - #[allow(unused_assignments)] - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - let frame_size = frame.size(); - let (max_major, max_minor) = to_mm(self.horizontal, frame_size.width, frame_size.height); - - let widthdb = frame.widthdb(); - let mut segments = [ $( - Segment::new( - size_async(self.horizontal, widthdb, &self.$arg, None, Some(max_minor)).await?, - &self.$arg, - ), - )+ ]; - balance(&mut segments, max_major); - - let mut major = 0_i32; - $( { - let balanced = &segments[$n]; - let (x, y) = from_mm(self.horizontal, major, 0); - let (w, h) = from_mm(self.horizontal, balanced.major, max_minor); - frame.push(Pos::new(x, y), Size::new(w, h)); - self.$arg.inner.draw(frame).await?; - frame.pop(); - major += balanced.major as i32; - } )* - - Ok(()) - } - } - }; -} - -mk_join! { - pub struct Join2 { - pub first: I1 [0], - pub second: I2 [1], - } -} - -mk_join! { - pub struct Join3 { - pub first: I1 [0], - pub second: I2 [1], - pub third: I3 [2], - } -} - -mk_join! { - pub struct Join4 { - pub first: I1 [0], - pub second: I2 [1], - pub third: I3 [2], - pub fourth: I4 [3], - } -} - -mk_join! { - pub struct Join5 { - pub first: I1 [0], - pub second: I2 [1], - pub third: I3 [2], - pub fourth: I4 [3], - pub fifth: I5 [4], - } -} - -mk_join! { - pub struct Join6 { - pub first: I1 [0], - pub second: I2 [1], - pub third: I3 [2], - pub fourth: I4 [3], - pub fifth: I5 [4], - pub sixth: I6 [5], - } -} - -mk_join! { - pub struct Join7 { - pub first: I1 [0], - pub second: I2 [1], - pub third: I3 [2], - pub fourth: I4 [3], - pub fifth: I5 [4], - pub sixth: I6 [5], - pub seventh: I7 [6], - } -} diff --git a/src/widgets/layer.rs b/src/widgets/layer.rs deleted file mode 100644 index af3da5e..0000000 --- a/src/widgets/layer.rs +++ /dev/null @@ -1,201 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Size, Widget, WidthDb}; - -#[derive(Debug, Clone)] -pub struct Layer { - layers: Vec, -} - -impl Layer { - pub fn new(layers: Vec) -> Self { - Self { layers } - } -} - -impl Widget for Layer -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let mut size = Size::ZERO; - for layer in &self.layers { - let lsize = layer.size(widthdb, max_width, max_height)?; - size.width = size.width.max(lsize.width); - size.height = size.height.max(lsize.height); - } - Ok(size) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - for layer in self.layers { - layer.draw(frame)?; - } - Ok(()) - } -} - -#[async_trait] -impl AsyncWidget for Layer -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let mut size = Size::ZERO; - for layer in &self.layers { - let lsize = layer.size(widthdb, max_width, max_height).await?; - size.width = size.width.max(lsize.width); - size.height = size.height.max(lsize.height); - } - Ok(size) - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - for layer in self.layers { - layer.draw(frame).await?; - } - Ok(()) - } -} - -macro_rules! mk_layer { - ( - pub struct $name:ident { - $( pub $arg:ident: $type:ident, )+ - } - ) => { - #[derive(Debug, Clone, Copy)] - pub struct $name< $($type),+ >{ - $( pub $arg: $type, )+ - } - - impl< $($type),+ > $name< $($type),+ >{ - pub fn new( $($arg: $type),+ ) -> Self { - Self { $( $arg, )+ } - } - } - - impl Widget for $name< $($type),+ > - where - $( $type: Widget, )+ - { - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let mut size = Size::ZERO; - - $({ - let lsize = self.$arg.size(widthdb, max_width, max_height)?; - size.width = size.width.max(lsize.width); - size.height = size.height.max(lsize.height); - })+ - - Ok(size) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - $( self.$arg.draw(frame)?; )+ - Ok(()) - } - } - - #[async_trait] - impl AsyncWidget for $name< $($type),+ > - where - E: Send, - $( $type: AsyncWidget + Send + Sync, )+ - { - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let mut size = Size::ZERO; - - $({ - let lsize = self.$arg.size(widthdb, max_width, max_height).await?; - size.width = size.width.max(lsize.width); - size.height = size.height.max(lsize.height); - })+ - - Ok(size) - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - $( self.$arg.draw(frame).await?; )+ - Ok(()) - } - } - }; -} - -mk_layer!( - pub struct Layer2 { - pub first: I1, - pub second: I2, - } -); - -mk_layer!( - pub struct Layer3 { - pub first: I1, - pub second: I2, - pub third: I3, - } -); - -mk_layer!( - pub struct Layer4 { - pub first: I1, - pub second: I2, - pub third: I3, - pub fourth: I4, - } -); - -mk_layer!( - pub struct Layer5 { - pub first: I1, - pub second: I2, - pub third: I3, - pub fourth: I4, - pub fifth: I5, - } -); - -mk_layer!( - pub struct Layer6 { - pub first: I1, - pub second: I2, - pub third: I3, - pub fourth: I4, - pub fifth: I5, - pub sixth: I6, - } -); - -mk_layer!( - pub struct Layer7 { - pub first: I1, - pub second: I2, - pub third: I3, - pub fourth: I4, - pub fifth: I5, - pub sixth: I6, - pub seventh: I7, - } -); diff --git a/src/widgets/padding.rs b/src/widgets/padding.rs deleted file mode 100644 index be3aff6..0000000 --- a/src/widgets/padding.rs +++ /dev/null @@ -1,133 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Pos, Size, Widget, WidthDb}; - -#[derive(Debug, Clone, Copy)] -pub struct Padding { - pub inner: I, - pub left: u16, - pub right: u16, - pub top: u16, - pub bottom: u16, - pub stretch: bool, -} - -impl Padding { - pub fn new(inner: I) -> Self { - Self { - inner, - left: 0, - right: 0, - top: 0, - bottom: 0, - stretch: false, - } - } - - pub fn with_left(mut self, amount: u16) -> Self { - self.left = amount; - self - } - - pub fn with_right(mut self, amount: u16) -> Self { - self.right = amount; - self - } - - pub fn with_top(mut self, amount: u16) -> Self { - self.top = amount; - self - } - - pub fn with_bottom(mut self, amount: u16) -> Self { - self.bottom = amount; - self - } - - pub fn with_horizontal(self, amount: u16) -> Self { - self.with_left(amount).with_right(amount) - } - - pub fn with_vertical(self, amount: u16) -> Self { - self.with_top(amount).with_bottom(amount) - } - - pub fn with_all(self, amount: u16) -> Self { - self.with_horizontal(amount).with_vertical(amount) - } - - pub fn with_stretch(mut self, stretch: bool) -> Self { - self.stretch = stretch; - self - } - - fn pad_size(&self) -> Size { - Size::new(self.left + self.right, self.top + self.bottom) - } - - fn push_inner(&self, frame: &mut Frame) { - let size = frame.size(); - let pad_size = self.pad_size(); - let inner_size = size.saturating_sub(pad_size); - frame.push(Pos::new(self.left.into(), self.top.into()), inner_size); - } -} - -impl Widget for Padding -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let pad_size = self.pad_size(); - let max_width = max_width.map(|w| w.saturating_sub(pad_size.width)); - let max_height = max_height.map(|h| h.saturating_sub(pad_size.height)); - let size = self.inner.size(widthdb, max_width, max_height)?; - Ok(size + pad_size) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - if self.stretch { - self.inner.draw(frame)?; - } else { - self.push_inner(frame); - self.inner.draw(frame)?; - frame.pop(); - } - Ok(()) - } -} - -#[async_trait] -impl AsyncWidget for Padding -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let pad_size = self.pad_size(); - let max_width = max_width.map(|w| w.saturating_sub(pad_size.width)); - let max_height = max_height.map(|h| h.saturating_sub(pad_size.height)); - let size = self.inner.size(widthdb, max_width, max_height).await?; - Ok(size + pad_size) - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - if self.stretch { - self.inner.draw(frame).await?; - } else { - self.push_inner(frame); - self.inner.draw(frame).await?; - frame.pop(); - } - Ok(()) - } -} diff --git a/src/widgets/predrawn.rs b/src/widgets/predrawn.rs deleted file mode 100644 index 8301f1e..0000000 --- a/src/widgets/predrawn.rs +++ /dev/null @@ -1,74 +0,0 @@ -use std::mem; - -use crate::buffer::Buffer; -use crate::{AsyncWidget, Frame, Pos, Size, Style, Styled, Widget, WidthDb}; - -#[derive(Debug, Clone)] -pub struct Predrawn { - buffer: Buffer, -} - -impl Predrawn { - pub fn new>(inner: W, widthdb: &mut WidthDb) -> Result { - let mut tmp_frame = Frame::default(); - - let size = inner.size(widthdb, None, None)?; - tmp_frame.buffer.resize(size); - - mem::swap(widthdb, &mut tmp_frame.widthdb); - inner.draw(&mut tmp_frame)?; - mem::swap(widthdb, &mut tmp_frame.widthdb); - - let buffer = tmp_frame.buffer; - Ok(Self { buffer }) - } - - pub async fn new_async>( - inner: W, - widthdb: &mut WidthDb, - ) -> Result { - let mut tmp_frame = Frame::default(); - - let size = inner.size(widthdb, None, None).await?; - tmp_frame.buffer.resize(size); - - mem::swap(widthdb, &mut tmp_frame.widthdb); - inner.draw(&mut tmp_frame).await?; - mem::swap(widthdb, &mut tmp_frame.widthdb); - - let buffer = tmp_frame.buffer; - Ok(Self { buffer }) - } - - pub fn size(&self) -> Size { - self.buffer.size() - } -} - -impl Widget for Predrawn { - fn size( - &self, - _widthdb: &mut WidthDb, - _max_width: Option, - _max_height: Option, - ) -> Result { - Ok(self.buffer.size()) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - for (x, y, cell) in self.buffer.cells() { - let pos = Pos::new(x.into(), y.into()); - let style = Style { - content_style: cell.style, - opaque: true, - }; - frame.write(pos, Styled::new(&cell.content, style)); - } - - if let Some(cursor) = self.buffer.cursor() { - frame.set_cursor(Some(cursor)); - } - - Ok(()) - } -} diff --git a/src/widgets/resize.rs b/src/widgets/resize.rs deleted file mode 100644 index 81e30b5..0000000 --- a/src/widgets/resize.rs +++ /dev/null @@ -1,120 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Size, Widget, WidthDb}; - -#[derive(Debug, Clone, Copy)] -pub struct Resize { - pub inner: I, - pub min_width: Option, - pub min_height: Option, - pub max_width: Option, - pub max_height: Option, -} - -impl Resize { - pub fn new(inner: I) -> Self { - Self { - inner, - min_width: None, - min_height: None, - max_width: None, - max_height: None, - } - } - - pub fn with_min_width(mut self, width: u16) -> Self { - self.min_width = Some(width); - self - } - - pub fn with_min_height(mut self, height: u16) -> Self { - self.min_height = Some(height); - self - } - - pub fn with_max_width(mut self, width: u16) -> Self { - self.max_width = Some(width); - self - } - - pub fn with_max_height(mut self, height: u16) -> Self { - self.max_height = Some(height); - self - } - - fn presize( - &self, - mut width: Option, - mut height: Option, - ) -> (Option, Option) { - if let Some(mw) = self.max_width { - width = Some(width.unwrap_or(mw).min(mw)); - } - if let Some(mh) = self.max_height { - height = Some(height.unwrap_or(mh).max(mh)); - } - (width, height) - } - - fn resize(&self, size: Size) -> Size { - let mut width = size.width; - let mut height = size.height; - - if let Some(min_width) = self.min_width { - width = width.max(min_width); - } - if let Some(min_height) = self.min_height { - height = height.max(min_height); - } - - if let Some(max_width) = self.max_width { - width = width.min(max_width); - } - if let Some(max_height) = self.max_height { - height = height.min(max_height); - } - - Size::new(width, height) - } -} - -impl Widget for Resize -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let (max_width, max_height) = self.presize(max_width, max_height); - let size = self.inner.size(widthdb, max_width, max_height)?; - Ok(self.resize(size)) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.inner.draw(frame) - } -} - -#[async_trait] -impl AsyncWidget for Resize -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - let (max_width, max_height) = self.presize(max_width, max_height); - let size = self.inner.size(widthdb, max_width, max_height).await?; - Ok(self.resize(size)) - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.inner.draw(frame).await - } -} diff --git a/src/widgets/text.rs b/src/widgets/text.rs deleted file mode 100644 index 007f4fe..0000000 --- a/src/widgets/text.rs +++ /dev/null @@ -1,68 +0,0 @@ -use crate::{Frame, Pos, Size, Styled, Widget, WidthDb}; - -#[derive(Debug, Clone)] -pub struct Text { - pub styled: Styled, - pub wrap: bool, -} - -impl Text { - pub fn new>(styled: S) -> Self { - Self { - styled: styled.into(), - wrap: true, - } - } - - pub fn with_wrap(mut self, active: bool) -> Self { - self.wrap = active; - self - } - - fn wrapped(&self, widthdb: &mut WidthDb, max_width: Option) -> Vec { - let max_width = max_width - .filter(|_| self.wrap) - .map(|w| w as usize) - .unwrap_or(usize::MAX); - - let indices = widthdb.wrap(self.styled.text(), max_width); - self.styled.clone().split_at_indices(&indices) - } -} - -impl Widget for Text { - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - _max_height: Option, - ) -> Result { - let lines = self.wrapped(widthdb, max_width); - - let min_width = lines - .iter() - .map(|l| widthdb.width(l.text().trim_end())) - .max() - .unwrap_or(0); - let min_height = lines.len(); - - let min_width: u16 = min_width.try_into().unwrap_or(u16::MAX); - let min_height: u16 = min_height.try_into().unwrap_or(u16::MAX); - Ok(Size::new(min_width, min_height)) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - let size = frame.size(); - - for (i, line) in self - .wrapped(frame.widthdb(), Some(size.width)) - .into_iter() - .enumerate() - { - let i: i32 = i.try_into().unwrap_or(i32::MAX); - frame.write(Pos::new(0, i), line); - } - - Ok(()) - } -} diff --git a/src/widgets/title.rs b/src/widgets/title.rs deleted file mode 100644 index c0dc0d4..0000000 --- a/src/widgets/title.rs +++ /dev/null @@ -1,59 +0,0 @@ -use async_trait::async_trait; - -use crate::{AsyncWidget, Frame, Size, Widget, WidthDb}; - -#[derive(Debug, Clone)] -pub struct Title { - pub inner: I, - pub title: String, -} - -impl Title { - pub fn new(inner: I, title: S) -> Self { - Self { - inner, - title: title.to_string(), - } - } -} - -impl Widget for Title -where - I: Widget, -{ - fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.inner.size(widthdb, max_width, max_height) - } - - fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.inner.draw(frame)?; - frame.set_title(Some(self.title)); - Ok(()) - } -} - -#[async_trait] -impl AsyncWidget for Title -where - I: AsyncWidget + Send + Sync, -{ - async fn size( - &self, - widthdb: &mut WidthDb, - max_width: Option, - max_height: Option, - ) -> Result { - self.inner.size(widthdb, max_width, max_height).await - } - - async fn draw(self, frame: &mut Frame) -> Result<(), E> { - self.inner.draw(frame).await?; - frame.set_title(Some(self.title)); - Ok(()) - } -} diff --git a/src/widthdb.rs b/src/widthdb.rs index fe5a26e..6af28c3 100644 --- a/src/widthdb.rs +++ b/src/widthdb.rs @@ -6,129 +6,51 @@ use crossterm::style::Print; use crossterm::terminal::{Clear, ClearType}; use crossterm::QueueableCommand; use unicode_segmentation::UnicodeSegmentation; -use unicode_width::{UnicodeWidthChar, UnicodeWidthStr}; - -use crate::wrap; - -#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] -pub enum WidthEstimationMethod { - /// Estimate the width of a grapheme using legacy methods. - /// - /// Different terminal emulators all use different approaches to determine - /// grapheme widths, so this method will never be able to give a fully - /// correct solution. For that, the only possible approach is measuring the - /// actual grapheme width. - #[default] - Legacy, - - /// Estimate the width of a grapheme using the unicode standard in a - /// best-effort manner. - Unicode, -} +use unicode_width::UnicodeWidthStr; /// Measures and stores the with (in terminal coordinates) of graphemes. -#[derive(Debug)] -pub struct WidthDb { - pub(crate) estimate: WidthEstimationMethod, - pub(crate) measure: bool, - pub(crate) tab_width: u8, +#[derive(Debug, Default)] +pub struct WidthDB { known: HashMap, requested: HashSet, } -impl Default for WidthDb { - fn default() -> Self { - Self { - estimate: WidthEstimationMethod::default(), - measure: false, - tab_width: 8, - known: Default::default(), - requested: Default::default(), - } - } -} - -impl WidthDb { - /// Determine the width of a tab character starting at the specified column. - fn tab_width_at_column(&self, col: usize) -> u8 { - self.tab_width - (col % self.tab_width as usize) as u8 - } - +impl WidthDB { /// Determine the width of a grapheme. /// - /// If the grapheme is a tab, the column is used to determine its width. - /// - /// If the width has not been measured yet or measurements are turned off, - /// it is estimated using the Unicode Standard Annex #11. - pub fn grapheme_width(&mut self, grapheme: &str, col: usize) -> u8 { + /// If the width has not been measured yet, it is estimated using the + /// Unicode Standard Annex #11. + pub fn grapheme_width(&mut self, grapheme: &str) -> u8 { assert_eq!(Some(grapheme), grapheme.graphemes(true).next()); - if grapheme == "\t" { - return self.tab_width_at_column(col); - } - - if self.measure { - if let Some(width) = self.known.get(grapheme) { - return *width; - } + if let Some(width) = self.known.get(grapheme) { + *width + } else { self.requested.insert(grapheme.to_string()); - } - - match self.estimate { - // A character-wise width calculation is a simple and obvious - // approach to compute character widths. The idea is that dumb - // terminal emulators tend to do something roughly like this, and - // smart terminal emulators try to emulate dumb ones for - // compatibility. In practice, this approach seems to be fairly - // robust. - WidthEstimationMethod::Legacy => grapheme - .chars() - .filter(|c| !c.is_ascii_control()) - .flat_map(|c| c.width()) - .sum::() - .try_into() - .unwrap_or(u8::MAX), - - // The unicode width crate considers control chars to have a width - // of 1 even though they usually have a width of 0 when displayed. - WidthEstimationMethod::Unicode => grapheme - .split(|c: char| c.is_ascii_control()) - .map(|s| s.width()) - .sum::() - .try_into() - .unwrap_or(u8::MAX), + grapheme.width() as u8 } } /// Determine the width of a string based on its graphemes. /// - /// If a grapheme is a tab, its column is used to determine its width. - /// - /// If the width of a grapheme has not been measured yet or measurements are - /// turned off, it is estimated using the Unicode Standard Annex #11. + /// If the width of a grapheme has not been measured yet, it is estimated + /// using the Unicode Standard Annex #11. pub fn width(&mut self, s: &str) -> usize { let mut total: usize = 0; for grapheme in s.graphemes(true) { - total += self.grapheme_width(grapheme, total) as usize; + total += if let Some(width) = self.known.get(grapheme) { + (*width).into() + } else { + self.requested.insert(grapheme.to_string()); + grapheme.width() + }; } total } - /// Perform primitive word wrapping with the specified maximum width. - /// - /// Returns the byte offsets at which the string should be split into lines. - /// An offset of 1 would mean the first line contains only a single byte. - /// These offsets lie on grapheme boundaries. - /// - /// This function does not support bidirectional script. It assumes the - /// entire text has the same direction. - pub fn wrap(&mut self, text: &str, width: usize) -> Vec { - wrap::wrap(self, text, width) - } - /// Whether any new graphemes have been seen since the last time /// [`Self::measure_widths`] was called. - pub(crate) fn measuring_required(&self) -> bool { - self.measure && !self.requested.is_empty() + pub fn measuring_required(&self) -> bool { + !self.requested.is_empty() } /// Measure the width of all new graphemes that have been seen since the @@ -137,20 +59,8 @@ impl WidthDb { /// This function measures the actual width of graphemes by writing them to /// the terminal. After it finishes, the terminal's contents should be /// assumed to be garbage and a full redraw should be performed. - pub(crate) fn measure_widths(&mut self, out: &mut impl Write) -> io::Result<()> { - if !self.measure { - return Ok(()); - } + pub fn measure_widths(&mut self, out: &mut impl Write) -> io::Result<()> { for grapheme in self.requested.drain() { - if grapheme.chars().any(|c| c.is_ascii_control()) { - // ASCII control characters like the escape character or the - // bell character tend to be interpreted specially by terminals. - // This may break width measurements. To avoid this, we just - // assign each control character a with of 0. - self.known.insert(grapheme, 0); - continue; - } - out.queue(Clear(ClearType::All))? .queue(MoveTo(0, 0))? .queue(Print(&grapheme))?; diff --git a/src/wrap.rs b/src/wrap.rs index a1ef1d4..309214a 100644 --- a/src/wrap.rs +++ b/src/wrap.rs @@ -3,21 +3,21 @@ use unicode_linebreak::BreakOpportunity; use unicode_segmentation::UnicodeSegmentation; -use crate::WidthDb; +use crate::widthdb::WidthDB; -pub fn wrap(widthdb: &mut WidthDb, text: &str, width: usize) -> Vec { +// TODO Handle tabs separately? +// TODO Convert into an iterator? +pub fn wrap(text: &str, width: usize, widthdb: &mut WidthDB) -> Vec { let mut breaks = vec![]; let mut break_options = unicode_linebreak::linebreaks(text).peekable(); // The last valid break point encountered and its width let mut valid_break = None; + let mut valid_break_width = 0; - // Starting index and width of the line at the current grapheme (with and - // without trailing whitespace) - let mut current_start = 0; + // Width of the line at the current grapheme let mut current_width = 0; - let mut current_width_trimmed = 0; for (gi, g) in text.grapheme_indices(true) { // Advance break options @@ -36,56 +36,60 @@ pub fn wrap(widthdb: &mut WidthDb, text: &str, width: usize) -> Vec { BreakOpportunity::Mandatory => { breaks.push(bi); valid_break = None; - current_start = bi; + valid_break_width = 0; current_width = 0; - current_width_trimmed = 0; } BreakOpportunity::Allowed => { valid_break = Some(bi); + valid_break_width = current_width; } } } - // Calculate widths after current grapheme - let g_is_whitespace = g.chars().all(|c| c.is_whitespace()); - let g_width = widthdb.grapheme_width(g, current_width) as usize; - current_width += g_width; - if !g_is_whitespace { - current_width_trimmed = current_width; - } - - // Wrap at last break point if necessary - if current_width_trimmed > width { - if let Some(bi) = valid_break { - let new_line = &text[bi..gi + g.len()]; - + let grapheme_width: usize = widthdb.grapheme_width(g).into(); + if current_width + grapheme_width > width { + if current_width == 0 { + // The grapheme is wider than the maximum width, so we'll allow + // it, thereby forcing the following grapheme to break no matter + // what (either because of a mandatory or allowed break, or via + // a forced break). + } else if let Some(bi) = valid_break { + // We can't fit the grapheme onto the current line, so we'll + // just break at the last valid break point. breaks.push(bi); + current_width -= valid_break_width; valid_break = None; - current_start = bi; - current_width = widthdb.width(new_line); - current_width_trimmed = widthdb.width(new_line.trim_end()); - } - } - - // Perform a forced break if still necessary - if current_width_trimmed > width { - if current_start == gi { - // The grapheme is the only thing on the current line and it is - // wider than the maximum width, so we'll allow it, thereby - // forcing the following grapheme to break no matter what - // (either because of a mandatory or allowed break, or via a - // forced break). + valid_break_width = 0; } else { - // Forced break in the middle of a normally non-breakable chunk - // because there are no valid break points. + // Forced break in the midde of a normally non-breakable chunk + // because there have been no valid break points yet. breaks.push(gi); valid_break = None; - current_start = gi; - current_width = widthdb.grapheme_width(g, 0).into(); - current_width_trimmed = if g_is_whitespace { 0 } else { current_width }; + valid_break_width = 0; + current_width = 0; } } + + current_width += grapheme_width; } breaks } + +pub fn split_at_indices<'a>(s: &'a str, indices: &[usize]) -> Vec<&'a str> { + let mut slices = vec![]; + + let mut rest = s; + let mut offset = 0; + + for i in indices { + let (left, right) = rest.split_at(i - offset); + slices.push(left); + rest = right; + offset = *i; + } + + slices.push(rest); + + slices +} diff --git a/widths-alacritty b/widths-alacritty new file mode 100644 index 0000000..1bf2ac3 --- /dev/null +++ b/widths-alacritty @@ -0,0 +1,2 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` diff --git a/widths-cool-retro-term b/widths-cool-retro-term new file mode 100644 index 0000000..fa4aed1 --- /dev/null +++ b/widths-cool-retro-term @@ -0,0 +1,5118 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +125260: actual 0, expected 1 +125261: actual 0, expected 1 +125262: actual 0, expected 1 +125263: actual 0, expected 1 +125274: actual 0, expected 1 +125275: actual 0, expected 1 +125276: actual 0, expected 1 +125277: actual 0, expected 1 +65795: actual 0, expected 1 +65796: actual 0, expected 1 +65797: actual 0, expected 1 +65798: actual 0, expected 1 +65844: actual 0, expected 1 +65845: actual 0, expected 1 +65846: actual 0, expected 1 +71451: actual 0, expected 1 +71452: actual 0, expected 1 +71468: actual 0, expected 1 +71469: actual 0, expected 1 +71470: actual 0, expected 1 +71471: actual 0, expected 1 +71488: actual 0, expected 1 +71489: actual 0, expected 1 +71490: actual 0, expected 1 +71491: actual 0, expected 1 +71492: actual 0, expected 1 +71493: actual 0, expected 1 +71494: actual 0, expected 1 +71495: actual 0, expected 1 +71496: actual 0, expected 1 +71497: actual 0, expected 1 +71498: actual 0, expected 1 +71499: actual 0, expected 1 +71500: actual 0, expected 1 +71501: actual 0, expected 1 +71502: actual 0, expected 1 +71503: actual 0, expected 1 +128884: actual 0, expected 1 +128885: actual 0, expected 1 +128886: actual 0, expected 1 +128887: actual 0, expected 1 +128888: actual 0, expected 1 +128889: actual 0, expected 1 +128890: actual 0, expected 1 +128891: actual 0, expected 1 +128892: actual 0, expected 1 +128893: actual 0, expected 1 +128894: actual 0, expected 1 +128895: actual 0, expected 1 +64263: actual 0, expected 1 +64264: actual 0, expected 1 +64265: actual 0, expected 1 +64266: actual 0, expected 1 +64267: actual 0, expected 1 +64268: actual 0, expected 1 +64269: actual 0, expected 1 +64270: actual 0, expected 1 +64271: actual 0, expected 1 +64272: actual 0, expected 1 +64273: actual 0, expected 1 +64274: actual 0, expected 1 +64280: actual 0, expected 1 +64281: actual 0, expected 1 +64282: actual 0, expected 1 +64283: actual 0, expected 1 +64284: actual 0, expected 1 +64311: actual 0, expected 1 +64317: actual 0, expected 1 +64319: actual 0, expected 1 +64322: actual 0, expected 1 +64325: actual 0, expected 1 +83527: actual 0, expected 1 +83528: actual 0, expected 1 +83529: actual 0, expected 1 +83530: actual 0, expected 1 +83531: actual 0, expected 1 +83532: actual 0, expected 1 +83533: actual 0, expected 1 +83534: actual 0, expected 1 +83535: actual 0, expected 1 +83536: actual 0, expected 1 +83537: actual 0, expected 1 +83538: actual 0, expected 1 +83539: actual 0, expected 1 +83540: actual 0, expected 1 +83541: actual 0, expected 1 +83542: actual 0, expected 1 +83543: actual 0, expected 1 +83544: actual 0, expected 1 +83545: actual 0, expected 1 +83546: actual 0, expected 1 +83547: actual 0, expected 1 +83548: actual 0, expected 1 +83549: actual 0, expected 1 +83550: actual 0, expected 1 +83551: actual 0, expected 1 +83552: actual 0, expected 1 +83553: actual 0, expected 1 +83554: actual 0, expected 1 +83555: actual 0, expected 1 +83556: actual 0, expected 1 +83557: actual 0, expected 1 +83558: actual 0, expected 1 +83559: actual 0, expected 1 +83560: actual 0, expected 1 +83561: actual 0, expected 1 +83562: actual 0, expected 1 +83563: actual 0, expected 1 +83564: actual 0, expected 1 +83565: actual 0, expected 1 +83566: actual 0, expected 1 +83567: actual 0, expected 1 +83568: actual 0, expected 1 +83569: actual 0, expected 1 +83570: actual 0, expected 1 +83571: actual 0, expected 1 +83572: actual 0, expected 1 +83573: actual 0, expected 1 +83574: actual 0, expected 1 +83575: actual 0, expected 1 +83576: actual 0, expected 1 +83577: actual 0, expected 1 +83578: actual 0, expected 1 +83579: actual 0, expected 1 +83580: actual 0, expected 1 +83581: actual 0, expected 1 +83582: actual 0, expected 1 +83583: actual 0, expected 1 +119366: actual 0, expected 1 +119367: actual 0, expected 1 +119368: actual 0, expected 1 +119369: actual 0, expected 1 +119370: actual 0, expected 1 +119371: actual 0, expected 1 +119372: actual 0, expected 1 +119373: actual 0, expected 1 +119374: actual 0, expected 1 +119375: actual 0, expected 1 +65935: actual 0, expected 1 +65949: actual 0, expected 1 +65950: actual 0, expected 1 +65951: actual 0, expected 1 +65953: actual 0, expected 1 +65954: actual 0, expected 1 +65955: actual 0, expected 1 +65956: actual 0, expected 1 +65957: actual 0, expected 1 +65958: actual 0, expected 1 +65959: actual 0, expected 1 +65960: actual 0, expected 1 +65961: actual 0, expected 1 +65962: actual 0, expected 1 +65963: actual 0, expected 1 +65964: actual 0, expected 1 +65965: actual 0, expected 1 +65966: actual 0, expected 1 +65967: actual 0, expected 1 +65968: actual 0, expected 1 +65969: actual 0, expected 1 +65970: actual 0, expected 1 +65971: actual 0, expected 1 +65972: actual 0, expected 1 +65973: actual 0, expected 1 +65974: actual 0, expected 1 +65975: actual 0, expected 1 +65976: actual 0, expected 1 +65977: actual 0, expected 1 +65978: actual 0, expected 1 +65979: actual 0, expected 1 +65980: actual 0, expected 1 +65981: actual 0, expected 1 +65982: actual 0, expected 1 +65983: actual 0, expected 1 +65984: actual 0, expected 1 +65985: actual 0, expected 1 +65986: actual 0, expected 1 +65987: actual 0, expected 1 +65988: actual 0, expected 1 +65989: actual 0, expected 1 +65990: actual 0, expected 1 +65991: actual 0, expected 1 +65992: actual 0, expected 1 +65993: actual 0, expected 1 +65994: actual 0, expected 1 +65995: actual 0, expected 1 +65996: actual 0, expected 1 +65997: actual 0, expected 1 +65998: actual 0, expected 1 +65999: actual 0, expected 1 +1536: actual 1, expected 0 +1537: actual 1, expected 0 +1538: actual 1, expected 0 +1539: actual 1, expected 0 +1540: actual 1, expected 0 +1541: actual 1, expected 0 +1565: actual 0, expected 1 +1757: actual 1, expected 0 +2229: actual 0, expected 1 +2248: actual 0, expected 1 +2249: actual 0, expected 1 +2274: actual 1, expected 0 +2160: actual 0, expected 1 +2161: actual 0, expected 1 +2162: actual 0, expected 1 +2163: actual 0, expected 1 +2164: actual 0, expected 1 +2165: actual 0, expected 1 +2166: actual 0, expected 1 +2167: actual 0, expected 1 +2168: actual 0, expected 1 +2169: actual 0, expected 1 +2170: actual 0, expected 1 +2171: actual 0, expected 1 +2172: actual 0, expected 1 +2173: actual 0, expected 1 +2174: actual 0, expected 1 +2175: actual 0, expected 1 +2176: actual 0, expected 1 +2177: actual 0, expected 1 +2178: actual 0, expected 1 +2179: actual 0, expected 1 +2180: actual 0, expected 1 +2181: actual 0, expected 1 +2182: actual 0, expected 1 +2183: actual 0, expected 1 +2184: actual 0, expected 1 +2185: actual 0, expected 1 +2186: actual 0, expected 1 +2187: actual 0, expected 1 +2188: actual 0, expected 1 +2189: actual 0, expected 1 +2190: actual 0, expected 1 +2191: actual 0, expected 1 +2194: actual 0, expected 1 +2195: actual 0, expected 1 +2196: actual 0, expected 1 +2197: actual 0, expected 1 +2198: actual 0, expected 1 +2199: actual 0, expected 1 +126468: actual 0, expected 1 +126496: actual 0, expected 1 +126499: actual 0, expected 1 +126501: actual 0, expected 1 +126502: actual 0, expected 1 +126504: actual 0, expected 1 +126515: actual 0, expected 1 +126520: actual 0, expected 1 +126522: actual 0, expected 1 +126524: actual 0, expected 1 +126525: actual 0, expected 1 +126526: actual 0, expected 1 +126527: actual 0, expected 1 +126528: actual 0, expected 1 +126529: actual 0, expected 1 +126531: actual 0, expected 1 +126532: actual 0, expected 1 +126533: actual 0, expected 1 +126534: actual 0, expected 1 +126536: actual 0, expected 1 +126538: actual 0, expected 1 +126540: actual 0, expected 1 +126544: actual 0, expected 1 +126547: actual 0, expected 1 +126549: actual 0, expected 1 +126550: actual 0, expected 1 +126552: actual 0, expected 1 +126554: actual 0, expected 1 +126556: actual 0, expected 1 +126558: actual 0, expected 1 +126560: actual 0, expected 1 +126563: actual 0, expected 1 +126565: actual 0, expected 1 +126566: actual 0, expected 1 +126571: actual 0, expected 1 +126579: actual 0, expected 1 +126584: actual 0, expected 1 +126589: actual 0, expected 1 +126591: actual 0, expected 1 +126602: actual 0, expected 1 +126620: actual 0, expected 1 +126621: actual 0, expected 1 +126622: actual 0, expected 1 +126623: actual 0, expected 1 +126624: actual 0, expected 1 +126628: actual 0, expected 1 +126634: actual 0, expected 1 +126652: actual 0, expected 1 +126653: actual 0, expected 1 +126654: actual 0, expected 1 +126655: actual 0, expected 1 +126656: actual 0, expected 1 +126657: actual 0, expected 1 +126658: actual 0, expected 1 +126659: actual 0, expected 1 +126660: actual 0, expected 1 +126661: actual 0, expected 1 +126662: actual 0, expected 1 +126663: actual 0, expected 1 +126664: actual 0, expected 1 +126665: actual 0, expected 1 +126666: actual 0, expected 1 +126667: actual 0, expected 1 +126668: actual 0, expected 1 +126669: actual 0, expected 1 +126670: actual 0, expected 1 +126671: actual 0, expected 1 +126672: actual 0, expected 1 +126673: actual 0, expected 1 +126674: actual 0, expected 1 +126675: actual 0, expected 1 +126676: actual 0, expected 1 +126677: actual 0, expected 1 +126678: actual 0, expected 1 +126679: actual 0, expected 1 +126680: actual 0, expected 1 +126681: actual 0, expected 1 +126682: actual 0, expected 1 +126683: actual 0, expected 1 +126684: actual 0, expected 1 +126685: actual 0, expected 1 +126686: actual 0, expected 1 +126687: actual 0, expected 1 +126688: actual 0, expected 1 +126689: actual 0, expected 1 +126690: actual 0, expected 1 +126691: actual 0, expected 1 +126692: actual 0, expected 1 +126693: actual 0, expected 1 +126694: actual 0, expected 1 +126695: actual 0, expected 1 +126696: actual 0, expected 1 +126697: actual 0, expected 1 +126698: actual 0, expected 1 +126699: actual 0, expected 1 +126700: actual 0, expected 1 +126701: actual 0, expected 1 +126702: actual 0, expected 1 +126703: actual 0, expected 1 +126706: actual 0, expected 1 +126707: actual 0, expected 1 +126708: actual 0, expected 1 +126709: actual 0, expected 1 +126710: actual 0, expected 1 +126711: actual 0, expected 1 +126712: actual 0, expected 1 +126713: actual 0, expected 1 +126714: actual 0, expected 1 +126715: actual 0, expected 1 +126716: actual 0, expected 1 +126717: actual 0, expected 1 +126718: actual 0, expected 1 +126719: actual 0, expected 1 +64450: actual 0, expected 1 +64451: actual 0, expected 1 +64452: actual 0, expected 1 +64453: actual 0, expected 1 +64454: actual 0, expected 1 +64455: actual 0, expected 1 +64456: actual 0, expected 1 +64457: actual 0, expected 1 +64458: actual 0, expected 1 +64459: actual 0, expected 1 +64460: actual 0, expected 1 +64461: actual 0, expected 1 +64462: actual 0, expected 1 +64463: actual 0, expected 1 +64464: actual 0, expected 1 +64465: actual 0, expected 1 +64466: actual 0, expected 1 +64832: actual 0, expected 1 +64833: actual 0, expected 1 +64834: actual 0, expected 1 +64835: actual 0, expected 1 +64836: actual 0, expected 1 +64837: actual 0, expected 1 +64838: actual 0, expected 1 +64839: actual 0, expected 1 +64840: actual 0, expected 1 +64841: actual 0, expected 1 +64842: actual 0, expected 1 +64843: actual 0, expected 1 +64844: actual 0, expected 1 +64845: actual 0, expected 1 +64846: actual 0, expected 1 +64847: actual 0, expected 1 +64912: actual 0, expected 1 +64913: actual 0, expected 1 +64968: actual 0, expected 1 +64969: actual 0, expected 1 +64970: actual 0, expected 1 +64971: actual 0, expected 1 +64972: actual 0, expected 1 +64973: actual 0, expected 1 +64974: actual 0, expected 1 +64975: actual 0, expected 1 +64976: actual 0, expected 1 +64977: actual 0, expected 1 +64978: actual 0, expected 1 +64979: actual 0, expected 1 +64980: actual 0, expected 1 +64981: actual 0, expected 1 +64982: actual 0, expected 1 +64983: actual 0, expected 1 +64984: actual 0, expected 1 +64985: actual 0, expected 1 +64986: actual 0, expected 1 +64987: actual 0, expected 1 +64988: actual 0, expected 1 +64989: actual 0, expected 1 +64990: actual 0, expected 1 +64991: actual 0, expected 1 +64992: actual 0, expected 1 +64993: actual 0, expected 1 +64994: actual 0, expected 1 +64995: actual 0, expected 1 +64996: actual 0, expected 1 +64997: actual 0, expected 1 +64998: actual 0, expected 1 +64999: actual 0, expected 1 +65000: actual 0, expected 1 +65001: actual 0, expected 1 +65002: actual 0, expected 1 +65003: actual 0, expected 1 +65004: actual 0, expected 1 +65005: actual 0, expected 1 +65006: actual 0, expected 1 +65007: actual 0, expected 1 +65022: actual 0, expected 1 +65023: actual 0, expected 1 +65141: actual 0, expected 1 +65277: actual 0, expected 1 +65278: actual 0, expected 1 +1328: actual 0, expected 1 +1367: actual 0, expected 1 +1368: actual 0, expected 1 +1419: actual 0, expected 1 +1420: actual 0, expected 1 +68406: actual 0, expected 1 +68407: actual 0, expected 1 +68408: actual 0, expected 1 +6988: actual 0, expected 1 +6989: actual 0, expected 1 +6990: actual 0, expected 1 +6991: actual 0, expected 1 +7037: actual 0, expected 1 +7038: actual 0, expected 1 +7039: actual 0, expected 1 +42744: actual 0, expected 1 +42745: actual 0, expected 1 +42746: actual 0, expected 1 +42747: actual 0, expected 1 +42748: actual 0, expected 1 +42749: actual 0, expected 1 +42750: actual 0, expected 1 +42751: actual 0, expected 1 +92729: actual 0, expected 1 +92730: actual 0, expected 1 +92731: actual 0, expected 1 +92732: actual 0, expected 1 +92733: actual 0, expected 1 +92734: actual 0, expected 1 +92735: actual 0, expected 1 +92910: actual 0, expected 1 +92911: actual 0, expected 1 +92918: actual 0, expected 1 +92919: actual 0, expected 1 +92920: actual 0, expected 1 +92921: actual 0, expected 1 +92922: actual 0, expected 1 +92923: actual 0, expected 1 +92924: actual 0, expected 1 +92925: actual 0, expected 1 +92926: actual 0, expected 1 +92927: actual 0, expected 1 +7156: actual 0, expected 1 +7157: actual 0, expected 1 +7158: actual 0, expected 1 +7159: actual 0, expected 1 +7160: actual 0, expected 1 +7161: actual 0, expected 1 +7162: actual 0, expected 1 +7163: actual 0, expected 1 +2436: actual 0, expected 1 +2445: actual 0, expected 1 +2446: actual 0, expected 1 +2449: actual 0, expected 1 +2450: actual 0, expected 1 +2473: actual 0, expected 1 +2481: actual 0, expected 1 +2483: actual 0, expected 1 +2484: actual 0, expected 1 +2485: actual 0, expected 1 +2490: actual 0, expected 1 +2491: actual 0, expected 1 +2501: actual 0, expected 1 +2502: actual 0, expected 1 +2505: actual 0, expected 1 +2506: actual 0, expected 1 +2511: actual 0, expected 1 +2512: actual 0, expected 1 +2513: actual 0, expected 1 +2514: actual 0, expected 1 +2515: actual 0, expected 1 +2516: actual 0, expected 1 +2517: actual 0, expected 1 +2518: actual 0, expected 1 +2520: actual 0, expected 1 +2521: actual 0, expected 1 +2522: actual 0, expected 1 +2523: actual 0, expected 1 +2526: actual 0, expected 1 +2532: actual 0, expected 1 +2533: actual 0, expected 1 +2559: actual 0, expected 1 +72713: actual 0, expected 1 +72759: actual 0, expected 1 +72774: actual 0, expected 1 +72775: actual 0, expected 1 +72776: actual 0, expected 1 +72777: actual 0, expected 1 +72778: actual 0, expected 1 +72779: actual 0, expected 1 +72780: actual 0, expected 1 +72781: actual 0, expected 1 +72782: actual 0, expected 1 +72783: actual 0, expected 1 +72813: actual 0, expected 1 +72814: actual 0, expected 1 +72815: actual 0, expected 1 +12544: actual 0, expected 1 +12545: actual 0, expected 1 +12546: actual 0, expected 1 +12547: actual 0, expected 1 +12548: actual 0, expected 1 +69710: actual 0, expected 1 +69711: actual 0, expected 1 +69712: actual 0, expected 1 +69713: actual 0, expected 1 +69745: actual 0, expected 1 +69746: actual 0, expected 1 +69749: actual 0, expected 1 +69750: actual 0, expected 1 +69751: actual 0, expected 1 +69752: actual 0, expected 1 +69753: actual 0, expected 1 +69754: actual 0, expected 1 +69755: actual 0, expected 1 +69756: actual 0, expected 1 +69757: actual 0, expected 1 +69758: actual 0, expected 1 +6684: actual 0, expected 1 +6685: actual 0, expected 1 +5972: actual 0, expected 1 +5973: actual 0, expected 1 +5974: actual 0, expected 1 +5975: actual 0, expected 1 +5976: actual 0, expected 1 +5977: actual 0, expected 1 +5978: actual 0, expected 1 +5979: actual 0, expected 1 +5980: actual 0, expected 1 +5981: actual 0, expected 1 +5982: actual 0, expected 1 +5983: actual 0, expected 1 +119030: actual 0, expected 1 +119031: actual 0, expected 1 +119032: actual 0, expected 1 +119033: actual 0, expected 1 +119034: actual 0, expected 1 +119035: actual 0, expected 1 +119036: actual 0, expected 1 +119037: actual 0, expected 1 +119038: actual 0, expected 1 +119039: actual 0, expected 1 +66257: actual 0, expected 1 +66258: actual 0, expected 1 +66259: actual 0, expected 1 +66260: actual 0, expected 1 +66261: actual 0, expected 1 +66262: actual 0, expected 1 +66263: actual 0, expected 1 +66264: actual 0, expected 1 +66265: actual 0, expected 1 +66266: actual 0, expected 1 +66267: actual 0, expected 1 +66268: actual 0, expected 1 +66269: actual 0, expected 1 +66270: actual 0, expected 1 +66271: actual 0, expected 1 +66916: actual 0, expected 1 +66917: actual 0, expected 1 +66918: actual 0, expected 1 +66919: actual 0, expected 1 +66920: actual 0, expected 1 +66921: actual 0, expected 1 +66922: actual 0, expected 1 +66923: actual 0, expected 1 +66924: actual 0, expected 1 +66925: actual 0, expected 1 +66926: actual 0, expected 1 +69941: actual 0, expected 1 +69960: actual 0, expected 1 +69961: actual 0, expected 1 +69962: actual 0, expected 1 +69963: actual 0, expected 1 +69964: actual 0, expected 1 +69965: actual 0, expected 1 +69966: actual 0, expected 1 +69967: actual 0, expected 1 +43575: actual 0, expected 1 +43576: actual 0, expected 1 +43577: actual 0, expected 1 +43578: actual 0, expected 1 +43579: actual 0, expected 1 +43580: actual 0, expected 1 +43581: actual 0, expected 1 +43582: actual 0, expected 1 +43583: actual 0, expected 1 +43598: actual 0, expected 1 +43599: actual 0, expected 1 +43610: actual 0, expected 1 +43611: actual 0, expected 1 +5110: actual 0, expected 1 +5111: actual 0, expected 1 +5118: actual 0, expected 1 +5119: actual 0, expected 1 +129620: actual 0, expected 1 +129621: actual 0, expected 1 +129622: actual 0, expected 1 +129623: actual 0, expected 1 +129624: actual 0, expected 1 +129625: actual 0, expected 1 +129626: actual 0, expected 1 +129627: actual 0, expected 1 +129628: actual 0, expected 1 +129629: actual 0, expected 1 +129630: actual 0, expected 1 +129631: actual 0, expected 1 +129646: actual 0, expected 1 +129647: actual 0, expected 1 +69580: actual 0, expected 1 +69581: actual 0, expected 1 +69582: actual 0, expected 1 +69583: actual 0, expected 1 +69584: actual 0, expected 1 +69585: actual 0, expected 1 +69586: actual 0, expected 1 +69587: actual 0, expected 1 +69588: actual 0, expected 1 +69589: actual 0, expected 1 +69590: actual 0, expected 1 +69591: actual 0, expected 1 +69592: actual 0, expected 1 +69593: actual 0, expected 1 +69594: actual 0, expected 1 +69595: actual 0, expected 1 +69596: actual 0, expected 1 +69597: actual 0, expected 1 +69598: actual 0, expected 1 +69599: actual 0, expected 1 +64110: actual 0, expected 2 +64111: actual 0, expected 2 +64218: actual 0, expected 2 +64219: actual 0, expected 2 +64220: actual 0, expected 2 +64221: actual 0, expected 2 +64222: actual 0, expected 2 +64223: actual 0, expected 2 +64224: actual 0, expected 2 +64225: actual 0, expected 2 +64226: actual 0, expected 2 +64227: actual 0, expected 2 +64228: actual 0, expected 2 +64229: actual 0, expected 2 +64230: actual 0, expected 2 +64231: actual 0, expected 2 +64232: actual 0, expected 2 +64233: actual 0, expected 2 +64234: actual 0, expected 2 +64235: actual 0, expected 2 +64236: actual 0, expected 2 +64237: actual 0, expected 2 +64238: actual 0, expected 2 +64239: actual 0, expected 2 +64240: actual 0, expected 2 +64241: actual 0, expected 2 +64242: actual 0, expected 2 +64243: actual 0, expected 2 +64244: actual 0, expected 2 +64245: actual 0, expected 2 +64246: actual 0, expected 2 +64247: actual 0, expected 2 +64248: actual 0, expected 2 +64249: actual 0, expected 2 +64250: actual 0, expected 2 +64251: actual 0, expected 2 +64252: actual 0, expected 2 +64253: actual 0, expected 2 +64254: actual 0, expected 2 +64255: actual 0, expected 2 +195102: actual 0, expected 2 +195103: actual 0, expected 2 +11930: actual 0, expected 1 +12020: actual 0, expected 1 +12021: actual 0, expected 1 +12022: actual 0, expected 1 +12023: actual 0, expected 1 +12024: actual 0, expected 1 +12025: actual 0, expected 1 +12026: actual 0, expected 1 +12027: actual 0, expected 1 +12028: actual 0, expected 1 +12029: actual 0, expected 1 +12030: actual 0, expected 1 +12031: actual 0, expected 1 +12772: actual 0, expected 1 +12773: actual 0, expected 1 +12774: actual 0, expected 1 +12775: actual 0, expected 1 +12776: actual 0, expected 1 +12777: actual 0, expected 1 +12778: actual 0, expected 1 +12779: actual 0, expected 1 +12780: actual 0, expected 1 +12781: actual 0, expected 1 +12782: actual 0, expected 1 +12783: actual 0, expected 1 +40957: actual 0, expected 2 +40958: actual 0, expected 2 +40959: actual 0, expected 2 +173790: actual 0, expected 2 +173791: actual 0, expected 2 +177973: actual 0, expected 2 +177974: actual 0, expected 2 +177975: actual 0, expected 2 +177976: actual 0, expected 2 +177977: actual 0, expected 2 +177978: actual 0, expected 2 +177979: actual 0, expected 2 +177980: actual 0, expected 2 +177981: actual 0, expected 2 +177982: actual 0, expected 2 +177983: actual 0, expected 2 +178206: actual 0, expected 2 +178207: actual 0, expected 2 +183970: actual 0, expected 2 +183971: actual 0, expected 2 +183972: actual 0, expected 2 +183973: actual 0, expected 2 +183974: actual 0, expected 2 +183975: actual 0, expected 2 +183976: actual 0, expected 2 +183977: actual 0, expected 2 +183978: actual 0, expected 2 +183979: actual 0, expected 2 +183980: actual 0, expected 2 +183981: actual 0, expected 2 +183982: actual 0, expected 2 +183983: actual 0, expected 2 +191457: actual 0, expected 2 +191458: actual 0, expected 2 +191459: actual 0, expected 2 +191460: actual 0, expected 2 +191461: actual 0, expected 2 +191462: actual 0, expected 2 +191463: actual 0, expected 2 +191464: actual 0, expected 2 +191465: actual 0, expected 2 +191466: actual 0, expected 2 +191467: actual 0, expected 2 +191468: actual 0, expected 2 +191469: actual 0, expected 2 +191470: actual 0, expected 2 +191471: actual 0, expected 2 +201547: actual 0, expected 2 +201548: actual 0, expected 2 +201549: actual 0, expected 2 +201550: actual 0, expected 2 +201551: actual 0, expected 2 +6863: actual 0, expected 1 +6864: actual 0, expected 1 +6865: actual 0, expected 1 +6866: actual 0, expected 1 +6867: actual 0, expected 1 +6868: actual 0, expected 1 +6869: actual 0, expected 1 +6870: actual 0, expected 1 +6871: actual 0, expected 1 +6872: actual 0, expected 1 +6873: actual 0, expected 1 +6874: actual 0, expected 1 +6875: actual 0, expected 1 +6876: actual 0, expected 1 +6877: actual 0, expected 1 +6878: actual 0, expected 1 +6879: actual 0, expected 1 +6880: actual 0, expected 1 +6881: actual 0, expected 1 +6882: actual 0, expected 1 +6883: actual 0, expected 1 +6884: actual 0, expected 1 +6885: actual 0, expected 1 +6886: actual 0, expected 1 +6887: actual 0, expected 1 +6888: actual 0, expected 1 +6889: actual 0, expected 1 +6890: actual 0, expected 1 +6891: actual 0, expected 1 +6892: actual 0, expected 1 +6893: actual 0, expected 1 +6894: actual 0, expected 1 +6895: actual 0, expected 1 +6896: actual 0, expected 1 +6897: actual 0, expected 1 +6898: actual 0, expected 1 +6899: actual 0, expected 1 +6900: actual 0, expected 1 +6901: actual 0, expected 1 +6902: actual 0, expected 1 +6903: actual 0, expected 1 +6904: actual 0, expected 1 +6905: actual 0, expected 1 +6906: actual 0, expected 1 +6907: actual 0, expected 1 +6908: actual 0, expected 1 +6909: actual 0, expected 1 +6910: actual 0, expected 1 +6911: actual 0, expected 1 +8433: actual 0, expected 1 +8434: actual 0, expected 1 +8435: actual 0, expected 1 +8436: actual 0, expected 1 +8437: actual 0, expected 1 +8438: actual 0, expected 1 +8439: actual 0, expected 1 +8440: actual 0, expected 1 +8441: actual 0, expected 1 +8442: actual 0, expected 1 +8443: actual 0, expected 1 +8444: actual 0, expected 1 +8445: actual 0, expected 1 +8446: actual 0, expected 1 +8447: actual 0, expected 1 +43066: actual 0, expected 1 +43067: actual 0, expected 1 +43068: actual 0, expected 1 +43069: actual 0, expected 1 +43070: actual 0, expected 1 +43071: actual 0, expected 1 +9255: actual 0, expected 1 +9256: actual 0, expected 1 +9257: actual 0, expected 1 +9258: actual 0, expected 1 +9259: actual 0, expected 1 +9260: actual 0, expected 1 +9261: actual 0, expected 1 +9262: actual 0, expected 1 +9263: actual 0, expected 1 +9264: actual 0, expected 1 +9265: actual 0, expected 1 +9266: actual 0, expected 1 +9267: actual 0, expected 1 +9268: actual 0, expected 1 +9269: actual 0, expected 1 +9270: actual 0, expected 1 +9271: actual 0, expected 1 +9272: actual 0, expected 1 +9273: actual 0, expected 1 +9274: actual 0, expected 1 +9275: actual 0, expected 1 +9276: actual 0, expected 1 +9277: actual 0, expected 1 +9278: actual 0, expected 1 +9279: actual 0, expected 1 +11508: actual 0, expected 1 +11509: actual 0, expected 1 +11510: actual 0, expected 1 +11511: actual 0, expected 1 +11512: actual 0, expected 1 +66300: actual 0, expected 1 +66301: actual 0, expected 1 +66302: actual 0, expected 1 +66303: actual 0, expected 1 +119673: actual 0, expected 1 +119674: actual 0, expected 1 +119675: actual 0, expected 1 +119676: actual 0, expected 1 +119677: actual 0, expected 1 +119678: actual 0, expected 1 +119679: actual 0, expected 1 +74650: actual 0, expected 1 +74651: actual 0, expected 1 +74652: actual 0, expected 1 +74653: actual 0, expected 1 +74654: actual 0, expected 1 +74655: actual 0, expected 1 +74656: actual 0, expected 1 +74657: actual 0, expected 1 +74658: actual 0, expected 1 +74659: actual 0, expected 1 +74660: actual 0, expected 1 +74661: actual 0, expected 1 +74662: actual 0, expected 1 +74663: actual 0, expected 1 +74664: actual 0, expected 1 +74665: actual 0, expected 1 +74666: actual 0, expected 1 +74667: actual 0, expected 1 +74668: actual 0, expected 1 +74669: actual 0, expected 1 +74670: actual 0, expected 1 +74671: actual 0, expected 1 +74672: actual 0, expected 1 +74673: actual 0, expected 1 +74674: actual 0, expected 1 +74675: actual 0, expected 1 +74676: actual 0, expected 1 +74677: actual 0, expected 1 +74678: actual 0, expected 1 +74679: actual 0, expected 1 +74680: actual 0, expected 1 +74681: actual 0, expected 1 +74682: actual 0, expected 1 +74683: actual 0, expected 1 +74684: actual 0, expected 1 +74685: actual 0, expected 1 +74686: actual 0, expected 1 +74687: actual 0, expected 1 +74688: actual 0, expected 1 +74689: actual 0, expected 1 +74690: actual 0, expected 1 +74691: actual 0, expected 1 +74692: actual 0, expected 1 +74693: actual 0, expected 1 +74694: actual 0, expected 1 +74695: actual 0, expected 1 +74696: actual 0, expected 1 +74697: actual 0, expected 1 +74698: actual 0, expected 1 +74699: actual 0, expected 1 +74700: actual 0, expected 1 +74701: actual 0, expected 1 +74702: actual 0, expected 1 +74703: actual 0, expected 1 +74704: actual 0, expected 1 +74705: actual 0, expected 1 +74706: actual 0, expected 1 +74707: actual 0, expected 1 +74708: actual 0, expected 1 +74709: actual 0, expected 1 +74710: actual 0, expected 1 +74711: actual 0, expected 1 +74712: actual 0, expected 1 +74713: actual 0, expected 1 +74714: actual 0, expected 1 +74715: actual 0, expected 1 +74716: actual 0, expected 1 +74717: actual 0, expected 1 +74718: actual 0, expected 1 +74719: actual 0, expected 1 +74720: actual 0, expected 1 +74721: actual 0, expected 1 +74722: actual 0, expected 1 +74723: actual 0, expected 1 +74724: actual 0, expected 1 +74725: actual 0, expected 1 +74726: actual 0, expected 1 +74727: actual 0, expected 1 +74728: actual 0, expected 1 +74729: actual 0, expected 1 +74730: actual 0, expected 1 +74731: actual 0, expected 1 +74732: actual 0, expected 1 +74733: actual 0, expected 1 +74734: actual 0, expected 1 +74735: actual 0, expected 1 +74736: actual 0, expected 1 +74737: actual 0, expected 1 +74738: actual 0, expected 1 +74739: actual 0, expected 1 +74740: actual 0, expected 1 +74741: actual 0, expected 1 +74742: actual 0, expected 1 +74743: actual 0, expected 1 +74744: actual 0, expected 1 +74745: actual 0, expected 1 +74746: actual 0, expected 1 +74747: actual 0, expected 1 +74748: actual 0, expected 1 +74749: actual 0, expected 1 +74750: actual 0, expected 1 +74751: actual 0, expected 1 +74863: actual 0, expected 1 +74869: actual 0, expected 1 +74870: actual 0, expected 1 +74871: actual 0, expected 1 +74872: actual 0, expected 1 +74873: actual 0, expected 1 +74874: actual 0, expected 1 +74875: actual 0, expected 1 +74876: actual 0, expected 1 +74877: actual 0, expected 1 +74878: actual 0, expected 1 +74879: actual 0, expected 1 +8384: actual 0, expected 1 +8385: actual 0, expected 1 +8386: actual 0, expected 1 +8387: actual 0, expected 1 +8388: actual 0, expected 1 +8389: actual 0, expected 1 +8390: actual 0, expected 1 +8391: actual 0, expected 1 +8392: actual 0, expected 1 +8393: actual 0, expected 1 +8394: actual 0, expected 1 +8395: actual 0, expected 1 +8396: actual 0, expected 1 +8397: actual 0, expected 1 +8398: actual 0, expected 1 +8399: actual 0, expected 1 +67590: actual 0, expected 1 +67591: actual 0, expected 1 +67593: actual 0, expected 1 +67638: actual 0, expected 1 +67641: actual 0, expected 1 +67642: actual 0, expected 1 +67643: actual 0, expected 1 +67645: actual 0, expected 1 +67646: actual 0, expected 1 +77712: actual 0, expected 1 +77713: actual 0, expected 1 +77714: actual 0, expected 1 +77715: actual 0, expected 1 +77716: actual 0, expected 1 +77717: actual 0, expected 1 +77718: actual 0, expected 1 +77719: actual 0, expected 1 +77720: actual 0, expected 1 +77721: actual 0, expected 1 +77722: actual 0, expected 1 +77723: actual 0, expected 1 +77724: actual 0, expected 1 +77725: actual 0, expected 1 +77726: actual 0, expected 1 +77727: actual 0, expected 1 +77728: actual 0, expected 1 +77729: actual 0, expected 1 +77730: actual 0, expected 1 +77731: actual 0, expected 1 +77732: actual 0, expected 1 +77733: actual 0, expected 1 +77734: actual 0, expected 1 +77735: actual 0, expected 1 +77736: actual 0, expected 1 +77737: actual 0, expected 1 +77738: actual 0, expected 1 +77739: actual 0, expected 1 +77740: actual 0, expected 1 +77741: actual 0, expected 1 +77742: actual 0, expected 1 +77743: actual 0, expected 1 +77744: actual 0, expected 1 +77745: actual 0, expected 1 +77746: actual 0, expected 1 +77747: actual 0, expected 1 +77748: actual 0, expected 1 +77749: actual 0, expected 1 +77750: actual 0, expected 1 +77751: actual 0, expected 1 +77752: actual 0, expected 1 +77753: actual 0, expected 1 +77754: actual 0, expected 1 +77755: actual 0, expected 1 +77756: actual 0, expected 1 +77757: actual 0, expected 1 +77758: actual 0, expected 1 +77759: actual 0, expected 1 +77760: actual 0, expected 1 +77761: actual 0, expected 1 +77762: actual 0, expected 1 +77763: actual 0, expected 1 +77764: actual 0, expected 1 +77765: actual 0, expected 1 +77766: actual 0, expected 1 +77767: actual 0, expected 1 +77768: actual 0, expected 1 +77769: actual 0, expected 1 +77770: actual 0, expected 1 +77771: actual 0, expected 1 +77772: actual 0, expected 1 +77773: actual 0, expected 1 +77774: actual 0, expected 1 +77775: actual 0, expected 1 +77776: actual 0, expected 1 +77777: actual 0, expected 1 +77778: actual 0, expected 1 +77779: actual 0, expected 1 +77780: actual 0, expected 1 +77781: actual 0, expected 1 +77782: actual 0, expected 1 +77783: actual 0, expected 1 +77784: actual 0, expected 1 +77785: actual 0, expected 1 +77786: actual 0, expected 1 +77787: actual 0, expected 1 +77788: actual 0, expected 1 +77789: actual 0, expected 1 +77790: actual 0, expected 1 +77791: actual 0, expected 1 +77792: actual 0, expected 1 +77793: actual 0, expected 1 +77794: actual 0, expected 1 +77795: actual 0, expected 1 +77796: actual 0, expected 1 +77797: actual 0, expected 1 +77798: actual 0, expected 1 +77799: actual 0, expected 1 +77800: actual 0, expected 1 +77801: actual 0, expected 1 +77802: actual 0, expected 1 +77803: actual 0, expected 1 +77804: actual 0, expected 1 +77805: actual 0, expected 1 +77806: actual 0, expected 1 +77807: actual 0, expected 1 +77808: actual 0, expected 1 +77809: actual 0, expected 1 +77810: actual 0, expected 1 +77811: actual 0, expected 1 +77812: actual 0, expected 1 +77813: actual 0, expected 1 +77814: actual 0, expected 1 +77815: actual 0, expected 1 +77816: actual 0, expected 1 +77817: actual 0, expected 1 +77818: actual 0, expected 1 +77819: actual 0, expected 1 +77820: actual 0, expected 1 +77821: actual 0, expected 1 +77822: actual 0, expected 1 +77823: actual 0, expected 1 +7305: actual 0, expected 1 +7306: actual 0, expected 1 +7307: actual 0, expected 1 +7308: actual 0, expected 1 +7309: actual 0, expected 1 +7310: actual 0, expected 1 +7311: actual 0, expected 1 +71943: actual 0, expected 1 +71944: actual 0, expected 1 +71946: actual 0, expected 1 +71947: actual 0, expected 1 +71956: actual 0, expected 1 +71959: actual 0, expected 1 +71990: actual 0, expected 1 +71993: actual 0, expected 1 +71994: actual 0, expected 1 +72007: actual 0, expected 1 +72008: actual 0, expected 1 +72009: actual 0, expected 1 +72010: actual 0, expected 1 +72011: actual 0, expected 1 +72012: actual 0, expected 1 +72013: actual 0, expected 1 +72014: actual 0, expected 1 +72015: actual 0, expected 1 +72026: actual 0, expected 1 +72027: actual 0, expected 1 +72028: actual 0, expected 1 +72029: actual 0, expected 1 +72030: actual 0, expected 1 +72031: actual 0, expected 1 +71740: actual 0, expected 1 +71741: actual 0, expected 1 +71742: actual 0, expected 1 +71743: actual 0, expected 1 +71744: actual 0, expected 1 +71745: actual 0, expected 1 +71746: actual 0, expected 1 +71747: actual 0, expected 1 +71748: actual 0, expected 1 +71749: actual 0, expected 1 +71750: actual 0, expected 1 +71751: actual 0, expected 1 +71752: actual 0, expected 1 +71753: actual 0, expected 1 +71754: actual 0, expected 1 +71755: actual 0, expected 1 +71756: actual 0, expected 1 +71757: actual 0, expected 1 +71758: actual 0, expected 1 +71759: actual 0, expected 1 +127124: actual 0, expected 1 +127125: actual 0, expected 1 +127126: actual 0, expected 1 +127127: actual 0, expected 1 +127128: actual 0, expected 1 +127129: actual 0, expected 1 +127130: actual 0, expected 1 +127131: actual 0, expected 1 +127132: actual 0, expected 1 +127133: actual 0, expected 1 +127134: actual 0, expected 1 +127135: actual 0, expected 1 +113771: actual 0, expected 1 +113772: actual 0, expected 1 +113773: actual 0, expected 1 +113774: actual 0, expected 1 +113775: actual 0, expected 1 +113789: actual 0, expected 1 +113790: actual 0, expected 1 +113791: actual 0, expected 1 +113801: actual 0, expected 1 +113802: actual 0, expected 1 +113803: actual 0, expected 1 +113804: actual 0, expected 1 +113805: actual 0, expected 1 +113806: actual 0, expected 1 +113807: actual 0, expected 1 +113818: actual 0, expected 1 +113819: actual 0, expected 1 +75076: actual 0, expected 1 +75077: actual 0, expected 1 +75078: actual 0, expected 1 +75079: actual 0, expected 1 +75080: actual 0, expected 1 +75081: actual 0, expected 1 +75082: actual 0, expected 1 +75083: actual 0, expected 1 +75084: actual 0, expected 1 +75085: actual 0, expected 1 +75086: actual 0, expected 1 +75087: actual 0, expected 1 +78895: actual 0, expected 1 +78905: actual 0, expected 1 +78906: actual 0, expected 1 +78907: actual 0, expected 1 +78908: actual 0, expected 1 +78909: actual 0, expected 1 +78910: actual 0, expected 1 +78911: actual 0, expected 1 +66856: actual 0, expected 1 +66857: actual 0, expected 1 +66858: actual 0, expected 1 +66859: actual 0, expected 1 +66860: actual 0, expected 1 +66861: actual 0, expected 1 +66862: actual 0, expected 1 +66863: actual 0, expected 1 +69623: actual 0, expected 1 +69624: actual 0, expected 1 +69625: actual 0, expected 1 +69626: actual 0, expected 1 +69627: actual 0, expected 1 +69628: actual 0, expected 1 +69629: actual 0, expected 1 +69630: actual 0, expected 1 +69631: actual 0, expected 1 +127406: actual 0, expected 1 +127407: actual 0, expected 1 +127408: actual 0, expected 1 +127409: actual 0, expected 1 +127410: actual 0, expected 1 +127411: actual 0, expected 1 +127412: actual 0, expected 1 +127413: actual 0, expected 1 +127414: actual 0, expected 1 +127415: actual 0, expected 1 +127416: actual 0, expected 1 +127417: actual 0, expected 1 +127418: actual 0, expected 1 +127419: actual 0, expected 1 +127420: actual 0, expected 1 +127421: actual 0, expected 1 +127422: actual 0, expected 1 +127423: actual 0, expected 1 +127424: actual 0, expected 1 +127425: actual 0, expected 1 +127426: actual 0, expected 1 +127427: actual 0, expected 1 +127428: actual 0, expected 1 +127429: actual 0, expected 1 +127430: actual 0, expected 1 +127431: actual 0, expected 1 +127432: actual 0, expected 1 +127433: actual 0, expected 1 +127434: actual 0, expected 1 +127435: actual 0, expected 1 +127436: actual 0, expected 1 +127437: actual 0, expected 1 +127438: actual 0, expected 1 +127439: actual 0, expected 1 +127440: actual 0, expected 1 +127441: actual 0, expected 1 +127442: actual 0, expected 1 +127443: actual 0, expected 1 +127444: actual 0, expected 1 +127445: actual 0, expected 1 +127446: actual 0, expected 1 +127447: actual 0, expected 1 +127448: actual 0, expected 1 +127449: actual 0, expected 1 +127450: actual 0, expected 1 +127451: actual 0, expected 1 +127452: actual 0, expected 1 +127453: actual 0, expected 1 +127454: actual 0, expected 1 +127455: actual 0, expected 1 +127456: actual 0, expected 1 +127457: actual 0, expected 1 +127458: actual 0, expected 1 +127459: actual 0, expected 1 +127460: actual 0, expected 1 +127461: actual 0, expected 1 +12831: actual 0, expected 1 +12872: actual 2, expected 1 +12873: actual 2, expected 1 +12874: actual 2, expected 1 +12875: actual 2, expected 1 +12876: actual 2, expected 1 +12877: actual 2, expected 1 +12878: actual 2, expected 1 +12879: actual 2, expected 1 +127491: actual 0, expected 1 +127492: actual 0, expected 1 +127493: actual 0, expected 1 +127494: actual 0, expected 1 +127495: actual 0, expected 1 +127496: actual 0, expected 1 +127497: actual 0, expected 1 +127498: actual 0, expected 1 +127499: actual 0, expected 1 +127500: actual 0, expected 1 +127501: actual 0, expected 1 +127502: actual 0, expected 1 +127503: actual 0, expected 1 +127548: actual 0, expected 1 +127549: actual 0, expected 1 +127550: actual 0, expected 1 +127551: actual 0, expected 1 +127561: actual 0, expected 1 +127562: actual 0, expected 1 +127563: actual 0, expected 1 +127564: actual 0, expected 1 +127565: actual 0, expected 1 +127566: actual 0, expected 1 +127567: actual 0, expected 1 +127570: actual 0, expected 1 +127571: actual 0, expected 1 +127572: actual 0, expected 1 +127573: actual 0, expected 1 +127574: actual 0, expected 1 +127575: actual 0, expected 1 +127576: actual 0, expected 1 +127577: actual 0, expected 1 +127578: actual 0, expected 1 +127579: actual 0, expected 1 +127580: actual 0, expected 1 +127581: actual 0, expected 1 +127582: actual 0, expected 1 +127583: actual 0, expected 1 +127590: actual 0, expected 1 +127591: actual 0, expected 1 +127592: actual 0, expected 1 +127593: actual 0, expected 1 +127594: actual 0, expected 1 +127595: actual 0, expected 1 +127596: actual 0, expected 1 +127597: actual 0, expected 1 +127598: actual 0, expected 1 +127599: actual 0, expected 1 +127600: actual 0, expected 1 +127601: actual 0, expected 1 +127602: actual 0, expected 1 +127603: actual 0, expected 1 +127604: actual 0, expected 1 +127605: actual 0, expected 1 +127606: actual 0, expected 1 +127607: actual 0, expected 1 +127608: actual 0, expected 1 +127609: actual 0, expected 1 +127610: actual 0, expected 1 +127611: actual 0, expected 1 +127612: actual 0, expected 1 +127613: actual 0, expected 1 +127614: actual 0, expected 1 +127615: actual 0, expected 1 +127616: actual 0, expected 1 +127617: actual 0, expected 1 +127618: actual 0, expected 1 +127619: actual 0, expected 1 +127620: actual 0, expected 1 +127621: actual 0, expected 1 +127622: actual 0, expected 1 +127623: actual 0, expected 1 +127624: actual 0, expected 1 +127625: actual 0, expected 1 +127626: actual 0, expected 1 +127627: actual 0, expected 1 +127628: actual 0, expected 1 +127629: actual 0, expected 1 +127630: actual 0, expected 1 +127631: actual 0, expected 1 +127632: actual 0, expected 1 +127633: actual 0, expected 1 +127634: actual 0, expected 1 +127635: actual 0, expected 1 +127636: actual 0, expected 1 +127637: actual 0, expected 1 +127638: actual 0, expected 1 +127639: actual 0, expected 1 +127640: actual 0, expected 1 +127641: actual 0, expected 1 +127642: actual 0, expected 1 +127643: actual 0, expected 1 +127644: actual 0, expected 1 +127645: actual 0, expected 1 +127646: actual 0, expected 1 +127647: actual 0, expected 1 +127648: actual 0, expected 1 +127649: actual 0, expected 1 +127650: actual 0, expected 1 +127651: actual 0, expected 1 +127652: actual 0, expected 1 +127653: actual 0, expected 1 +127654: actual 0, expected 1 +127655: actual 0, expected 1 +127656: actual 0, expected 1 +127657: actual 0, expected 1 +127658: actual 0, expected 1 +127659: actual 0, expected 1 +127660: actual 0, expected 1 +127661: actual 0, expected 1 +127662: actual 0, expected 1 +127663: actual 0, expected 1 +127664: actual 0, expected 1 +127665: actual 0, expected 1 +127666: actual 0, expected 1 +127667: actual 0, expected 1 +127668: actual 0, expected 1 +127669: actual 0, expected 1 +127670: actual 0, expected 1 +127671: actual 0, expected 1 +127672: actual 0, expected 1 +127673: actual 0, expected 1 +127674: actual 0, expected 1 +127675: actual 0, expected 1 +127676: actual 0, expected 1 +127677: actual 0, expected 1 +127678: actual 0, expected 1 +127679: actual 0, expected 1 +127680: actual 0, expected 1 +127681: actual 0, expected 1 +127682: actual 0, expected 1 +127683: actual 0, expected 1 +127684: actual 0, expected 1 +127685: actual 0, expected 1 +127686: actual 0, expected 1 +127687: actual 0, expected 1 +127688: actual 0, expected 1 +127689: actual 0, expected 1 +127690: actual 0, expected 1 +127691: actual 0, expected 1 +127692: actual 0, expected 1 +127693: actual 0, expected 1 +127694: actual 0, expected 1 +127695: actual 0, expected 1 +127696: actual 0, expected 1 +127697: actual 0, expected 1 +127698: actual 0, expected 1 +127699: actual 0, expected 1 +127700: actual 0, expected 1 +127701: actual 0, expected 1 +127702: actual 0, expected 1 +127703: actual 0, expected 1 +127704: actual 0, expected 1 +127705: actual 0, expected 1 +127706: actual 0, expected 1 +127707: actual 0, expected 1 +127708: actual 0, expected 1 +127709: actual 0, expected 1 +127710: actual 0, expected 1 +127711: actual 0, expected 1 +127712: actual 0, expected 1 +127713: actual 0, expected 1 +127714: actual 0, expected 1 +127715: actual 0, expected 1 +127716: actual 0, expected 1 +127717: actual 0, expected 1 +127718: actual 0, expected 1 +127719: actual 0, expected 1 +127720: actual 0, expected 1 +127721: actual 0, expected 1 +127722: actual 0, expected 1 +127723: actual 0, expected 1 +127724: actual 0, expected 1 +127725: actual 0, expected 1 +127726: actual 0, expected 1 +127727: actual 0, expected 1 +127728: actual 0, expected 1 +127729: actual 0, expected 1 +127730: actual 0, expected 1 +127731: actual 0, expected 1 +127732: actual 0, expected 1 +127733: actual 0, expected 1 +127734: actual 0, expected 1 +127735: actual 0, expected 1 +127736: actual 0, expected 1 +127737: actual 0, expected 1 +127738: actual 0, expected 1 +127739: actual 0, expected 1 +127740: actual 0, expected 1 +127741: actual 0, expected 1 +127742: actual 0, expected 1 +127743: actual 0, expected 1 +4681: actual 0, expected 1 +4686: actual 0, expected 1 +4687: actual 0, expected 1 +4695: actual 0, expected 1 +4697: actual 0, expected 1 +4702: actual 0, expected 1 +4703: actual 0, expected 1 +4745: actual 0, expected 1 +4750: actual 0, expected 1 +4751: actual 0, expected 1 +4785: actual 0, expected 1 +4790: actual 0, expected 1 +4791: actual 0, expected 1 +4799: actual 0, expected 1 +4801: actual 0, expected 1 +4806: actual 0, expected 1 +4807: actual 0, expected 1 +4823: actual 0, expected 1 +4881: actual 0, expected 1 +4886: actual 0, expected 1 +4887: actual 0, expected 1 +4955: actual 0, expected 1 +4956: actual 0, expected 1 +4989: actual 0, expected 1 +4990: actual 0, expected 1 +4991: actual 0, expected 1 +11671: actual 0, expected 1 +11672: actual 0, expected 1 +11673: actual 0, expected 1 +11674: actual 0, expected 1 +11675: actual 0, expected 1 +11676: actual 0, expected 1 +11677: actual 0, expected 1 +11678: actual 0, expected 1 +11679: actual 0, expected 1 +11687: actual 0, expected 1 +11695: actual 0, expected 1 +11703: actual 0, expected 1 +11711: actual 0, expected 1 +11719: actual 0, expected 1 +11727: actual 0, expected 1 +11735: actual 0, expected 1 +11743: actual 0, expected 1 +43776: actual 0, expected 1 +43783: actual 0, expected 1 +43784: actual 0, expected 1 +43791: actual 0, expected 1 +43792: actual 0, expected 1 +43799: actual 0, expected 1 +43800: actual 0, expected 1 +43801: actual 0, expected 1 +43802: actual 0, expected 1 +43803: actual 0, expected 1 +43804: actual 0, expected 1 +43805: actual 0, expected 1 +43806: actual 0, expected 1 +43807: actual 0, expected 1 +43815: actual 0, expected 1 +43823: actual 0, expected 1 +124896: actual 0, expected 1 +124897: actual 0, expected 1 +124898: actual 0, expected 1 +124899: actual 0, expected 1 +124900: actual 0, expected 1 +124901: actual 0, expected 1 +124902: actual 0, expected 1 +124903: actual 0, expected 1 +124904: actual 0, expected 1 +124905: actual 0, expected 1 +124906: actual 0, expected 1 +124907: actual 0, expected 1 +124908: actual 0, expected 1 +124909: actual 0, expected 1 +124910: actual 0, expected 1 +124911: actual 0, expected 1 +124912: actual 0, expected 1 +124913: actual 0, expected 1 +124914: actual 0, expected 1 +124915: actual 0, expected 1 +124916: actual 0, expected 1 +124917: actual 0, expected 1 +124918: actual 0, expected 1 +124919: actual 0, expected 1 +124920: actual 0, expected 1 +124921: actual 0, expected 1 +124922: actual 0, expected 1 +124923: actual 0, expected 1 +124924: actual 0, expected 1 +124925: actual 0, expected 1 +124926: actual 0, expected 1 +124927: actual 0, expected 1 +5018: actual 0, expected 1 +5019: actual 0, expected 1 +5020: actual 0, expected 1 +5021: actual 0, expected 1 +5022: actual 0, expected 1 +5023: actual 0, expected 1 +8232: actual 0, expected 1 +8233: actual 0, expected 1 +8293: actual 0, expected 1 +128985: actual 0, expected 1 +128986: actual 0, expected 1 +128987: actual 0, expected 1 +128988: actual 0, expected 1 +128989: actual 0, expected 1 +128990: actual 0, expected 1 +128991: actual 0, expected 1 +129004: actual 0, expected 1 +129005: actual 0, expected 1 +129006: actual 0, expected 1 +129007: actual 0, expected 1 +129008: actual 0, expected 2 +129009: actual 0, expected 1 +129010: actual 0, expected 1 +129011: actual 0, expected 1 +129012: actual 0, expected 1 +129013: actual 0, expected 1 +129014: actual 0, expected 1 +129015: actual 0, expected 1 +129016: actual 0, expected 1 +129017: actual 0, expected 1 +129018: actual 0, expected 1 +129019: actual 0, expected 1 +129020: actual 0, expected 1 +129021: actual 0, expected 1 +129022: actual 0, expected 1 +129023: actual 0, expected 1 +4294: actual 0, expected 1 +4296: actual 0, expected 1 +4297: actual 0, expected 1 +4298: actual 0, expected 1 +4299: actual 0, expected 1 +4300: actual 0, expected 1 +4302: actual 0, expected 1 +4303: actual 0, expected 1 +7355: actual 0, expected 1 +7356: actual 0, expected 1 +11558: actual 0, expected 1 +11560: actual 0, expected 1 +11561: actual 0, expected 1 +11562: actual 0, expected 1 +11563: actual 0, expected 1 +11564: actual 0, expected 1 +11566: actual 0, expected 1 +11567: actual 0, expected 1 +11311: actual 0, expected 1 +11359: actual 0, expected 1 +122887: actual 0, expected 1 +122905: actual 0, expected 1 +122906: actual 0, expected 1 +122914: actual 0, expected 1 +122917: actual 0, expected 1 +122923: actual 0, expected 1 +122924: actual 0, expected 1 +122925: actual 0, expected 1 +122926: actual 0, expected 1 +122927: actual 0, expected 1 +66379: actual 0, expected 1 +66380: actual 0, expected 1 +66381: actual 0, expected 1 +66382: actual 0, expected 1 +66383: actual 0, expected 1 +70404: actual 0, expected 1 +70413: actual 0, expected 1 +70414: actual 0, expected 1 +70417: actual 0, expected 1 +70418: actual 0, expected 1 +70441: actual 0, expected 1 +70449: actual 0, expected 1 +70452: actual 0, expected 1 +70458: actual 0, expected 1 +70469: actual 0, expected 1 +70470: actual 0, expected 1 +70473: actual 0, expected 1 +70474: actual 0, expected 1 +70478: actual 0, expected 1 +70479: actual 0, expected 1 +70481: actual 0, expected 1 +70482: actual 0, expected 1 +70483: actual 0, expected 1 +70484: actual 0, expected 1 +70485: actual 0, expected 1 +70486: actual 0, expected 1 +70488: actual 0, expected 1 +70489: actual 0, expected 1 +70490: actual 0, expected 1 +70491: actual 0, expected 1 +70492: actual 0, expected 1 +70500: actual 0, expected 1 +70501: actual 0, expected 1 +70509: actual 0, expected 1 +70510: actual 0, expected 1 +70511: actual 0, expected 1 +70517: actual 0, expected 1 +70518: actual 0, expected 1 +70519: actual 0, expected 1 +70520: actual 0, expected 1 +70521: actual 0, expected 1 +70522: actual 0, expected 1 +70523: actual 0, expected 1 +70524: actual 0, expected 1 +70525: actual 0, expected 1 +70526: actual 0, expected 1 +70527: actual 0, expected 1 +888: actual 0, expected 1 +889: actual 0, expected 1 +896: actual 0, expected 1 +897: actual 0, expected 1 +898: actual 0, expected 1 +899: actual 0, expected 1 +907: actual 0, expected 1 +909: actual 0, expected 1 +930: actual 0, expected 1 +7958: actual 0, expected 1 +7959: actual 0, expected 1 +7966: actual 0, expected 1 +7967: actual 0, expected 1 +8006: actual 0, expected 1 +8007: actual 0, expected 1 +8014: actual 0, expected 1 +8015: actual 0, expected 1 +8024: actual 0, expected 1 +8026: actual 0, expected 1 +8028: actual 0, expected 1 +8030: actual 0, expected 1 +8062: actual 0, expected 1 +8063: actual 0, expected 1 +8117: actual 0, expected 1 +8133: actual 0, expected 1 +8148: actual 0, expected 1 +8149: actual 0, expected 1 +8156: actual 0, expected 1 +8176: actual 0, expected 1 +8177: actual 0, expected 1 +8181: actual 0, expected 1 +8191: actual 0, expected 1 +2688: actual 0, expected 1 +2692: actual 0, expected 1 +2702: actual 0, expected 1 +2706: actual 0, expected 1 +2729: actual 0, expected 1 +2737: actual 0, expected 1 +2740: actual 0, expected 1 +2746: actual 0, expected 1 +2747: actual 0, expected 1 +2758: actual 0, expected 1 +2762: actual 0, expected 1 +2766: actual 0, expected 1 +2767: actual 0, expected 1 +2769: actual 0, expected 1 +2770: actual 0, expected 1 +2771: actual 0, expected 1 +2772: actual 0, expected 1 +2773: actual 0, expected 1 +2774: actual 0, expected 1 +2775: actual 0, expected 1 +2776: actual 0, expected 1 +2777: actual 0, expected 1 +2778: actual 0, expected 1 +2779: actual 0, expected 1 +2780: actual 0, expected 1 +2781: actual 0, expected 1 +2782: actual 0, expected 1 +2783: actual 0, expected 1 +2788: actual 0, expected 1 +2789: actual 0, expected 1 +2802: actual 0, expected 1 +2803: actual 0, expected 1 +2804: actual 0, expected 1 +2805: actual 0, expected 1 +2806: actual 0, expected 1 +2807: actual 0, expected 1 +2808: actual 0, expected 1 +73062: actual 0, expected 1 +73065: actual 0, expected 1 +73103: actual 0, expected 1 +73106: actual 0, expected 1 +73113: actual 0, expected 1 +73114: actual 0, expected 1 +73115: actual 0, expected 1 +73116: actual 0, expected 1 +73117: actual 0, expected 1 +73118: actual 0, expected 1 +73119: actual 0, expected 1 +73130: actual 0, expected 1 +73131: actual 0, expected 1 +73132: actual 0, expected 1 +73133: actual 0, expected 1 +73134: actual 0, expected 1 +73135: actual 0, expected 1 +2560: actual 0, expected 1 +2564: actual 0, expected 1 +2571: actual 0, expected 1 +2572: actual 0, expected 1 +2573: actual 0, expected 1 +2574: actual 0, expected 1 +2577: actual 0, expected 1 +2578: actual 0, expected 1 +2601: actual 0, expected 1 +2609: actual 0, expected 1 +2612: actual 0, expected 1 +2615: actual 0, expected 1 +2618: actual 0, expected 1 +2619: actual 0, expected 1 +2621: actual 0, expected 1 +2627: actual 0, expected 1 +2628: actual 0, expected 1 +2629: actual 0, expected 1 +2630: actual 0, expected 1 +2633: actual 0, expected 1 +2634: actual 0, expected 1 +2638: actual 0, expected 1 +2639: actual 0, expected 1 +2640: actual 0, expected 1 +2642: actual 0, expected 1 +2643: actual 0, expected 1 +2644: actual 0, expected 1 +2645: actual 0, expected 1 +2646: actual 0, expected 1 +2647: actual 0, expected 1 +2648: actual 0, expected 1 +2653: actual 0, expected 1 +2655: actual 0, expected 1 +2656: actual 0, expected 1 +2657: actual 0, expected 1 +2658: actual 0, expected 1 +2659: actual 0, expected 1 +2660: actual 0, expected 1 +2661: actual 0, expected 1 +2679: actual 0, expected 1 +2680: actual 0, expected 1 +2681: actual 0, expected 1 +2682: actual 0, expected 1 +2683: actual 0, expected 1 +2684: actual 0, expected 1 +2685: actual 0, expected 1 +2686: actual 0, expected 1 +2687: actual 0, expected 1 +65280: actual 0, expected 1 +65471: actual 0, expected 1 +65472: actual 0, expected 1 +65473: actual 0, expected 1 +65480: actual 0, expected 1 +65481: actual 0, expected 1 +65488: actual 0, expected 1 +65489: actual 0, expected 1 +65496: actual 0, expected 1 +65497: actual 0, expected 1 +65501: actual 0, expected 1 +65502: actual 0, expected 1 +65503: actual 0, expected 1 +65511: actual 0, expected 1 +65519: actual 0, expected 1 +12592: actual 0, expected 1 +12687: actual 0, expected 1 +43389: actual 0, expected 1 +43390: actual 0, expected 1 +43391: actual 0, expected 1 +55216: actual 0, expected 1 +55217: actual 0, expected 1 +55218: actual 0, expected 1 +55219: actual 0, expected 1 +55220: actual 0, expected 1 +55221: actual 0, expected 1 +55222: actual 0, expected 1 +55223: actual 0, expected 1 +55224: actual 0, expected 1 +55225: actual 0, expected 1 +55226: actual 0, expected 1 +55227: actual 0, expected 1 +55228: actual 0, expected 1 +55229: actual 0, expected 1 +55230: actual 0, expected 1 +55231: actual 0, expected 1 +55232: actual 0, expected 1 +55233: actual 0, expected 1 +55234: actual 0, expected 1 +55235: actual 0, expected 1 +55236: actual 0, expected 1 +55237: actual 0, expected 1 +55238: actual 0, expected 1 +55239: actual 0, expected 1 +55240: actual 0, expected 1 +55241: actual 0, expected 1 +55242: actual 0, expected 1 +55243: actual 0, expected 1 +55244: actual 0, expected 1 +55245: actual 0, expected 1 +55246: actual 0, expected 1 +55247: actual 0, expected 1 +55248: actual 0, expected 1 +55249: actual 0, expected 1 +55250: actual 0, expected 1 +55251: actual 0, expected 1 +55252: actual 0, expected 1 +55253: actual 0, expected 1 +55254: actual 0, expected 1 +55255: actual 0, expected 1 +55256: actual 0, expected 1 +55257: actual 0, expected 1 +55258: actual 0, expected 1 +55259: actual 0, expected 1 +55260: actual 0, expected 1 +55261: actual 0, expected 1 +55262: actual 0, expected 1 +55263: actual 0, expected 1 +55264: actual 0, expected 1 +55265: actual 0, expected 1 +55266: actual 0, expected 1 +55267: actual 0, expected 1 +55268: actual 0, expected 1 +55269: actual 0, expected 1 +55270: actual 0, expected 1 +55271: actual 0, expected 1 +55272: actual 0, expected 1 +55273: actual 0, expected 1 +55274: actual 0, expected 1 +55275: actual 0, expected 1 +55276: actual 0, expected 1 +55277: actual 0, expected 1 +55278: actual 0, expected 1 +55279: actual 0, expected 1 +55280: actual 0, expected 1 +55281: actual 0, expected 1 +55282: actual 0, expected 1 +55283: actual 0, expected 1 +55284: actual 0, expected 1 +55285: actual 0, expected 1 +55286: actual 0, expected 1 +55287: actual 0, expected 1 +55288: actual 0, expected 1 +55289: actual 0, expected 1 +55290: actual 0, expected 1 +55291: actual 0, expected 1 +55292: actual 0, expected 1 +55293: actual 0, expected 1 +55294: actual 0, expected 1 +55295: actual 0, expected 1 +55204: actual 0, expected 1 +55205: actual 0, expected 1 +55206: actual 0, expected 1 +55207: actual 0, expected 1 +55208: actual 0, expected 1 +55209: actual 0, expected 1 +55210: actual 0, expected 1 +55211: actual 0, expected 1 +55212: actual 0, expected 1 +55213: actual 0, expected 1 +55214: actual 0, expected 1 +55215: actual 0, expected 1 +68904: actual 0, expected 1 +68905: actual 0, expected 1 +68906: actual 0, expected 1 +68907: actual 0, expected 1 +68908: actual 0, expected 1 +68909: actual 0, expected 1 +68910: actual 0, expected 1 +68911: actual 0, expected 1 +68922: actual 0, expected 1 +68923: actual 0, expected 1 +68924: actual 0, expected 1 +68925: actual 0, expected 1 +68926: actual 0, expected 1 +68927: actual 0, expected 1 +5940: actual 0, expected 1 +5943: actual 0, expected 1 +5944: actual 0, expected 1 +5945: actual 0, expected 1 +5946: actual 0, expected 1 +5947: actual 0, expected 1 +5948: actual 0, expected 1 +5949: actual 0, expected 1 +5950: actual 0, expected 1 +5951: actual 0, expected 1 +67827: actual 0, expected 1 +67830: actual 0, expected 1 +67831: actual 0, expected 1 +67832: actual 0, expected 1 +67833: actual 0, expected 1 +67834: actual 0, expected 1 +1424: actual 0, expected 1 +1480: actual 0, expected 1 +1481: actual 0, expected 1 +1482: actual 0, expected 1 +1483: actual 0, expected 1 +1484: actual 0, expected 1 +1485: actual 0, expected 1 +1486: actual 0, expected 1 +1487: actual 0, expected 1 +1515: actual 0, expected 1 +1516: actual 0, expected 1 +1517: actual 0, expected 1 +1518: actual 0, expected 1 +1525: actual 0, expected 1 +1526: actual 0, expected 1 +1527: actual 0, expected 1 +1528: actual 0, expected 1 +1529: actual 0, expected 1 +1530: actual 0, expected 1 +1531: actual 0, expected 1 +1532: actual 0, expected 1 +1533: actual 0, expected 1 +1534: actual 0, expected 1 +1535: actual 0, expected 1 +12352: actual 0, expected 1 +12439: actual 0, expected 1 +12440: actual 0, expected 1 +12284: actual 0, expected 1 +12285: actual 0, expected 1 +12286: actual 0, expected 1 +12287: actual 0, expected 1 +94181: actual 0, expected 1 +94182: actual 0, expected 1 +94183: actual 0, expected 1 +94184: actual 0, expected 1 +94185: actual 0, expected 1 +94186: actual 0, expected 1 +94187: actual 0, expected 1 +94188: actual 0, expected 1 +94189: actual 0, expected 1 +94190: actual 0, expected 1 +94191: actual 0, expected 1 +94194: actual 0, expected 1 +94195: actual 0, expected 1 +94196: actual 0, expected 1 +94197: actual 0, expected 1 +94198: actual 0, expected 1 +94199: actual 0, expected 1 +94200: actual 0, expected 1 +94201: actual 0, expected 1 +94202: actual 0, expected 1 +94203: actual 0, expected 1 +94204: actual 0, expected 1 +94205: actual 0, expected 1 +94206: actual 0, expected 1 +94207: actual 0, expected 1 +67670: actual 0, expected 1 +126064: actual 0, expected 1 +126133: actual 0, expected 1 +126134: actual 0, expected 1 +126135: actual 0, expected 1 +126136: actual 0, expected 1 +126137: actual 0, expected 1 +126138: actual 0, expected 1 +126139: actual 0, expected 1 +126140: actual 0, expected 1 +126141: actual 0, expected 1 +126142: actual 0, expected 1 +126143: actual 0, expected 1 +68467: actual 0, expected 1 +68468: actual 0, expected 1 +68469: actual 0, expected 1 +68470: actual 0, expected 1 +68471: actual 0, expected 1 +68438: actual 0, expected 1 +68439: actual 0, expected 1 +43470: actual 0, expected 1 +43482: actual 0, expected 1 +43483: actual 0, expected 1 +43484: actual 0, expected 1 +43485: actual 0, expected 1 +69821: actual 1, expected 0 +69827: actual 0, expected 1 +69828: actual 0, expected 1 +69829: actual 0, expected 1 +69830: actual 0, expected 1 +69831: actual 0, expected 1 +69832: actual 0, expected 1 +69833: actual 0, expected 1 +69834: actual 0, expected 1 +69835: actual 0, expected 1 +69836: actual 0, expected 1 +69837: actual 1, expected 0 +69838: actual 0, expected 1 +69839: actual 0, expected 1 +110879: actual 0, expected 2 +110880: actual 0, expected 2 +110881: actual 0, expected 2 +110882: actual 0, expected 2 +110883: actual 0, expected 1 +110884: actual 0, expected 1 +110885: actual 0, expected 1 +110886: actual 0, expected 1 +110887: actual 0, expected 1 +110888: actual 0, expected 1 +110889: actual 0, expected 1 +110890: actual 0, expected 1 +110891: actual 0, expected 1 +110892: actual 0, expected 1 +110893: actual 0, expected 1 +110894: actual 0, expected 1 +110895: actual 0, expected 1 +110576: actual 0, expected 2 +110577: actual 0, expected 2 +110578: actual 0, expected 2 +110579: actual 0, expected 2 +110580: actual 0, expected 1 +110581: actual 0, expected 2 +110582: actual 0, expected 2 +110583: actual 0, expected 2 +110584: actual 0, expected 2 +110585: actual 0, expected 2 +110586: actual 0, expected 2 +110587: actual 0, expected 2 +110588: actual 0, expected 1 +110589: actual 0, expected 2 +110590: actual 0, expected 2 +110591: actual 0, expected 1 +12246: actual 0, expected 1 +12247: actual 0, expected 1 +12248: actual 0, expected 1 +12249: actual 0, expected 1 +12250: actual 0, expected 1 +12251: actual 0, expected 1 +12252: actual 0, expected 1 +12253: actual 0, expected 1 +12254: actual 0, expected 1 +12255: actual 0, expected 1 +3213: actual 0, expected 1 +3217: actual 0, expected 1 +3241: actual 0, expected 1 +3252: actual 0, expected 1 +3258: actual 0, expected 1 +3259: actual 0, expected 1 +3269: actual 0, expected 1 +3273: actual 0, expected 1 +3278: actual 0, expected 1 +3279: actual 0, expected 1 +3280: actual 0, expected 1 +3281: actual 0, expected 1 +3282: actual 0, expected 1 +3283: actual 0, expected 1 +3284: actual 0, expected 1 +3287: actual 0, expected 1 +3288: actual 0, expected 1 +3289: actual 0, expected 1 +3290: actual 0, expected 1 +3291: actual 0, expected 1 +3292: actual 0, expected 1 +3293: actual 0, expected 1 +3295: actual 0, expected 1 +3300: actual 0, expected 1 +3301: actual 0, expected 1 +3312: actual 0, expected 1 +3315: actual 0, expected 1 +3316: actual 0, expected 1 +3317: actual 0, expected 1 +3318: actual 0, expected 1 +3319: actual 0, expected 1 +3320: actual 0, expected 1 +3321: actual 0, expected 1 +3322: actual 0, expected 1 +3323: actual 0, expected 1 +3324: actual 0, expected 1 +3325: actual 0, expected 1 +3326: actual 0, expected 1 +3327: actual 0, expected 1 +68100: actual 0, expected 1 +68103: actual 0, expected 1 +68104: actual 0, expected 1 +68105: actual 0, expected 1 +68106: actual 0, expected 1 +68107: actual 0, expected 1 +68116: actual 0, expected 1 +68120: actual 0, expected 1 +68150: actual 0, expected 1 +68151: actual 0, expected 1 +68155: actual 0, expected 1 +68156: actual 0, expected 1 +68157: actual 0, expected 1 +68158: actual 0, expected 1 +68169: actual 0, expected 1 +68170: actual 0, expected 1 +68171: actual 0, expected 1 +68172: actual 0, expected 1 +68173: actual 0, expected 1 +68174: actual 0, expected 1 +68175: actual 0, expected 1 +68185: actual 0, expected 1 +68186: actual 0, expected 1 +68187: actual 0, expected 1 +68188: actual 0, expected 1 +68189: actual 0, expected 1 +68190: actual 0, expected 1 +68191: actual 0, expected 1 +101590: actual 0, expected 1 +101591: actual 0, expected 1 +101592: actual 0, expected 1 +101593: actual 0, expected 1 +101594: actual 0, expected 1 +101595: actual 0, expected 1 +101596: actual 0, expected 1 +101597: actual 0, expected 1 +101598: actual 0, expected 1 +101599: actual 0, expected 1 +101600: actual 0, expected 1 +101601: actual 0, expected 1 +101602: actual 0, expected 1 +101603: actual 0, expected 1 +101604: actual 0, expected 1 +101605: actual 0, expected 1 +101606: actual 0, expected 1 +101607: actual 0, expected 1 +101608: actual 0, expected 1 +101609: actual 0, expected 1 +101610: actual 0, expected 1 +101611: actual 0, expected 1 +101612: actual 0, expected 1 +101613: actual 0, expected 1 +101614: actual 0, expected 1 +101615: actual 0, expected 1 +101616: actual 0, expected 1 +101617: actual 0, expected 1 +101618: actual 0, expected 1 +101619: actual 0, expected 1 +101620: actual 0, expected 1 +101621: actual 0, expected 1 +101622: actual 0, expected 1 +101623: actual 0, expected 1 +101624: actual 0, expected 1 +101625: actual 0, expected 1 +101626: actual 0, expected 1 +101627: actual 0, expected 1 +101628: actual 0, expected 1 +101629: actual 0, expected 1 +101630: actual 0, expected 1 +101631: actual 0, expected 1 +6110: actual 0, expected 1 +6111: actual 0, expected 1 +6122: actual 0, expected 1 +6123: actual 0, expected 1 +6124: actual 0, expected 1 +6125: actual 0, expected 1 +6126: actual 0, expected 1 +6127: actual 0, expected 1 +6138: actual 0, expected 1 +6139: actual 0, expected 1 +6140: actual 0, expected 1 +6141: actual 0, expected 1 +6142: actual 0, expected 1 +6143: actual 0, expected 1 +70162: actual 0, expected 1 +70207: actual 0, expected 1 +70208: actual 0, expected 1 +70209: actual 0, expected 1 +70210: actual 0, expected 1 +70211: actual 0, expected 1 +70212: actual 0, expected 1 +70213: actual 0, expected 1 +70214: actual 0, expected 1 +70215: actual 0, expected 1 +70216: actual 0, expected 1 +70217: actual 0, expected 1 +70218: actual 0, expected 1 +70219: actual 0, expected 1 +70220: actual 0, expected 1 +70221: actual 0, expected 1 +70222: actual 0, expected 1 +70223: actual 0, expected 1 +70379: actual 0, expected 1 +70380: actual 0, expected 1 +70381: actual 0, expected 1 +70382: actual 0, expected 1 +70383: actual 0, expected 1 +70394: actual 0, expected 1 +70395: actual 0, expected 1 +70396: actual 0, expected 1 +70397: actual 0, expected 1 +70398: actual 0, expected 1 +70399: actual 0, expected 1 +3712: actual 0, expected 1 +3715: actual 0, expected 1 +3717: actual 0, expected 1 +3723: actual 0, expected 1 +3748: actual 0, expected 1 +3750: actual 0, expected 1 +3774: actual 0, expected 1 +3775: actual 0, expected 1 +3781: actual 0, expected 1 +3783: actual 0, expected 1 +3790: actual 0, expected 1 +3791: actual 0, expected 1 +3802: actual 0, expected 1 +3803: actual 0, expected 1 +3808: actual 0, expected 1 +3809: actual 0, expected 1 +3810: actual 0, expected 1 +3811: actual 0, expected 1 +3812: actual 0, expected 1 +3813: actual 0, expected 1 +3814: actual 0, expected 1 +3815: actual 0, expected 1 +3816: actual 0, expected 1 +3817: actual 0, expected 1 +3818: actual 0, expected 1 +3819: actual 0, expected 1 +3820: actual 0, expected 1 +3821: actual 0, expected 1 +3822: actual 0, expected 1 +3823: actual 0, expected 1 +3824: actual 0, expected 1 +3825: actual 0, expected 1 +3826: actual 0, expected 1 +3827: actual 0, expected 1 +3828: actual 0, expected 1 +3829: actual 0, expected 1 +3830: actual 0, expected 1 +3831: actual 0, expected 1 +3832: actual 0, expected 1 +3833: actual 0, expected 1 +3834: actual 0, expected 1 +3835: actual 0, expected 1 +3836: actual 0, expected 1 +3837: actual 0, expected 1 +3838: actual 0, expected 1 +3839: actual 0, expected 1 +42944: actual 0, expected 1 +42945: actual 0, expected 1 +42955: actual 0, expected 1 +42956: actual 0, expected 1 +42957: actual 0, expected 1 +42958: actual 0, expected 1 +42959: actual 0, expected 1 +42960: actual 0, expected 1 +42961: actual 0, expected 1 +42962: actual 0, expected 1 +42963: actual 0, expected 1 +42964: actual 0, expected 1 +42965: actual 0, expected 1 +42966: actual 0, expected 1 +42967: actual 0, expected 1 +42968: actual 0, expected 1 +42969: actual 0, expected 1 +42970: actual 0, expected 1 +42971: actual 0, expected 1 +42972: actual 0, expected 1 +42973: actual 0, expected 1 +42974: actual 0, expected 1 +42975: actual 0, expected 1 +42976: actual 0, expected 1 +42977: actual 0, expected 1 +42978: actual 0, expected 1 +42979: actual 0, expected 1 +42980: actual 0, expected 1 +42981: actual 0, expected 1 +42982: actual 0, expected 1 +42983: actual 0, expected 1 +42984: actual 0, expected 1 +42985: actual 0, expected 1 +42986: actual 0, expected 1 +42987: actual 0, expected 1 +42988: actual 0, expected 1 +42989: actual 0, expected 1 +42990: actual 0, expected 1 +42991: actual 0, expected 1 +42992: actual 0, expected 1 +42993: actual 0, expected 1 +42994: actual 0, expected 1 +42995: actual 0, expected 1 +42996: actual 0, expected 1 +43884: actual 0, expected 1 +43885: actual 0, expected 1 +43886: actual 0, expected 1 +43887: actual 0, expected 1 +67456: actual 0, expected 1 +67457: actual 0, expected 1 +67458: actual 0, expected 1 +67459: actual 0, expected 1 +67460: actual 0, expected 1 +67461: actual 0, expected 1 +67462: actual 0, expected 1 +67463: actual 0, expected 1 +67464: actual 0, expected 1 +67465: actual 0, expected 1 +67466: actual 0, expected 1 +67467: actual 0, expected 1 +67468: actual 0, expected 1 +67469: actual 0, expected 1 +67470: actual 0, expected 1 +67471: actual 0, expected 1 +67472: actual 0, expected 1 +67473: actual 0, expected 1 +67474: actual 0, expected 1 +67475: actual 0, expected 1 +67476: actual 0, expected 1 +67477: actual 0, expected 1 +67478: actual 0, expected 1 +67479: actual 0, expected 1 +67480: actual 0, expected 1 +67481: actual 0, expected 1 +67482: actual 0, expected 1 +67483: actual 0, expected 1 +67484: actual 0, expected 1 +67485: actual 0, expected 1 +67486: actual 0, expected 1 +67487: actual 0, expected 1 +67488: actual 0, expected 1 +67489: actual 0, expected 1 +67490: actual 0, expected 1 +67491: actual 0, expected 1 +67492: actual 0, expected 1 +67493: actual 0, expected 1 +67494: actual 0, expected 1 +67495: actual 0, expected 1 +67496: actual 0, expected 1 +67497: actual 0, expected 1 +67498: actual 0, expected 1 +67499: actual 0, expected 1 +67500: actual 0, expected 1 +67501: actual 0, expected 1 +67502: actual 0, expected 1 +67503: actual 0, expected 1 +67504: actual 0, expected 1 +67505: actual 0, expected 1 +67506: actual 0, expected 1 +67507: actual 0, expected 1 +67508: actual 0, expected 1 +67509: actual 0, expected 1 +67510: actual 0, expected 1 +67511: actual 0, expected 1 +67512: actual 0, expected 1 +67513: actual 0, expected 1 +67514: actual 0, expected 1 +67515: actual 0, expected 1 +67516: actual 0, expected 1 +67517: actual 0, expected 1 +67518: actual 0, expected 1 +67519: actual 0, expected 1 +122624: actual 0, expected 1 +122625: actual 0, expected 1 +122626: actual 0, expected 1 +122627: actual 0, expected 1 +122628: actual 0, expected 1 +122629: actual 0, expected 1 +122630: actual 0, expected 1 +122631: actual 0, expected 1 +122632: actual 0, expected 1 +122633: actual 0, expected 1 +122634: actual 0, expected 1 +122635: actual 0, expected 1 +122636: actual 0, expected 1 +122637: actual 0, expected 1 +122638: actual 0, expected 1 +122639: actual 0, expected 1 +122640: actual 0, expected 1 +122641: actual 0, expected 1 +122642: actual 0, expected 1 +122643: actual 0, expected 1 +122644: actual 0, expected 1 +122645: actual 0, expected 1 +122646: actual 0, expected 1 +122647: actual 0, expected 1 +122648: actual 0, expected 1 +122649: actual 0, expected 1 +122650: actual 0, expected 1 +122651: actual 0, expected 1 +122652: actual 0, expected 1 +122653: actual 0, expected 1 +122654: actual 0, expected 1 +122655: actual 0, expected 1 +122656: actual 0, expected 1 +122657: actual 0, expected 1 +122658: actual 0, expected 1 +122659: actual 0, expected 1 +122660: actual 0, expected 1 +122661: actual 0, expected 1 +122662: actual 0, expected 1 +122663: actual 0, expected 1 +122664: actual 0, expected 1 +122665: actual 0, expected 1 +122666: actual 0, expected 1 +122667: actual 0, expected 1 +122668: actual 0, expected 1 +122669: actual 0, expected 1 +122670: actual 0, expected 1 +122671: actual 0, expected 1 +122672: actual 0, expected 1 +122673: actual 0, expected 1 +122674: actual 0, expected 1 +122675: actual 0, expected 1 +122676: actual 0, expected 1 +122677: actual 0, expected 1 +122678: actual 0, expected 1 +122679: actual 0, expected 1 +122680: actual 0, expected 1 +122681: actual 0, expected 1 +122682: actual 0, expected 1 +122683: actual 0, expected 1 +122684: actual 0, expected 1 +122685: actual 0, expected 1 +122686: actual 0, expected 1 +122687: actual 0, expected 1 +122688: actual 0, expected 1 +122689: actual 0, expected 1 +122690: actual 0, expected 1 +122691: actual 0, expected 1 +122692: actual 0, expected 1 +122693: actual 0, expected 1 +122694: actual 0, expected 1 +122695: actual 0, expected 1 +122696: actual 0, expected 1 +122697: actual 0, expected 1 +122698: actual 0, expected 1 +122699: actual 0, expected 1 +122700: actual 0, expected 1 +122701: actual 0, expected 1 +122702: actual 0, expected 1 +122703: actual 0, expected 1 +122704: actual 0, expected 1 +122705: actual 0, expected 1 +122706: actual 0, expected 1 +122707: actual 0, expected 1 +122708: actual 0, expected 1 +122709: actual 0, expected 1 +122710: actual 0, expected 1 +122711: actual 0, expected 1 +122712: actual 0, expected 1 +122713: actual 0, expected 1 +122714: actual 0, expected 1 +122715: actual 0, expected 1 +122716: actual 0, expected 1 +122717: actual 0, expected 1 +122718: actual 0, expected 1 +122719: actual 0, expected 1 +122720: actual 0, expected 1 +122721: actual 0, expected 1 +122722: actual 0, expected 1 +122723: actual 0, expected 1 +122724: actual 0, expected 1 +122725: actual 0, expected 1 +122726: actual 0, expected 1 +122727: actual 0, expected 1 +122728: actual 0, expected 1 +122729: actual 0, expected 1 +122730: actual 0, expected 1 +122731: actual 0, expected 1 +122732: actual 0, expected 1 +122733: actual 0, expected 1 +122734: actual 0, expected 1 +122735: actual 0, expected 1 +122736: actual 0, expected 1 +122737: actual 0, expected 1 +122738: actual 0, expected 1 +122739: actual 0, expected 1 +122740: actual 0, expected 1 +122741: actual 0, expected 1 +122742: actual 0, expected 1 +122743: actual 0, expected 1 +122744: actual 0, expected 1 +122745: actual 0, expected 1 +122746: actual 0, expected 1 +122747: actual 0, expected 1 +122748: actual 0, expected 1 +122749: actual 0, expected 1 +122750: actual 0, expected 1 +122751: actual 0, expected 1 +122752: actual 0, expected 1 +122753: actual 0, expected 1 +122754: actual 0, expected 1 +122755: actual 0, expected 1 +122756: actual 0, expected 1 +122757: actual 0, expected 1 +122758: actual 0, expected 1 +122759: actual 0, expected 1 +122760: actual 0, expected 1 +122761: actual 0, expected 1 +122762: actual 0, expected 1 +122763: actual 0, expected 1 +122764: actual 0, expected 1 +122765: actual 0, expected 1 +122766: actual 0, expected 1 +122767: actual 0, expected 1 +122768: actual 0, expected 1 +122769: actual 0, expected 1 +122770: actual 0, expected 1 +122771: actual 0, expected 1 +122772: actual 0, expected 1 +122773: actual 0, expected 1 +122774: actual 0, expected 1 +122775: actual 0, expected 1 +122776: actual 0, expected 1 +122777: actual 0, expected 1 +122778: actual 0, expected 1 +122779: actual 0, expected 1 +122780: actual 0, expected 1 +122781: actual 0, expected 1 +122782: actual 0, expected 1 +122783: actual 0, expected 1 +122784: actual 0, expected 1 +122785: actual 0, expected 1 +122786: actual 0, expected 1 +122787: actual 0, expected 1 +122788: actual 0, expected 1 +122789: actual 0, expected 1 +122790: actual 0, expected 1 +122791: actual 0, expected 1 +122792: actual 0, expected 1 +122793: actual 0, expected 1 +122794: actual 0, expected 1 +122795: actual 0, expected 1 +122796: actual 0, expected 1 +122797: actual 0, expected 1 +122798: actual 0, expected 1 +122799: actual 0, expected 1 +122800: actual 0, expected 1 +122801: actual 0, expected 1 +122802: actual 0, expected 1 +122803: actual 0, expected 1 +122804: actual 0, expected 1 +122805: actual 0, expected 1 +122806: actual 0, expected 1 +122807: actual 0, expected 1 +122808: actual 0, expected 1 +122809: actual 0, expected 1 +122810: actual 0, expected 1 +122811: actual 0, expected 1 +122812: actual 0, expected 1 +122813: actual 0, expected 1 +122814: actual 0, expected 1 +122815: actual 0, expected 1 +122816: actual 0, expected 1 +122817: actual 0, expected 1 +122818: actual 0, expected 1 +122819: actual 0, expected 1 +122820: actual 0, expected 1 +122821: actual 0, expected 1 +122822: actual 0, expected 1 +122823: actual 0, expected 1 +122824: actual 0, expected 1 +122825: actual 0, expected 1 +122826: actual 0, expected 1 +122827: actual 0, expected 1 +122828: actual 0, expected 1 +122829: actual 0, expected 1 +122830: actual 0, expected 1 +122831: actual 0, expected 1 +122832: actual 0, expected 1 +122833: actual 0, expected 1 +122834: actual 0, expected 1 +122835: actual 0, expected 1 +122836: actual 0, expected 1 +122837: actual 0, expected 1 +122838: actual 0, expected 1 +122839: actual 0, expected 1 +122840: actual 0, expected 1 +122841: actual 0, expected 1 +122842: actual 0, expected 1 +122843: actual 0, expected 1 +122844: actual 0, expected 1 +122845: actual 0, expected 1 +122846: actual 0, expected 1 +122847: actual 0, expected 1 +122848: actual 0, expected 1 +122849: actual 0, expected 1 +122850: actual 0, expected 1 +122851: actual 0, expected 1 +122852: actual 0, expected 1 +122853: actual 0, expected 1 +122854: actual 0, expected 1 +122855: actual 0, expected 1 +122856: actual 0, expected 1 +122857: actual 0, expected 1 +122858: actual 0, expected 1 +122859: actual 0, expected 1 +122860: actual 0, expected 1 +122861: actual 0, expected 1 +122862: actual 0, expected 1 +122863: actual 0, expected 1 +122864: actual 0, expected 1 +122865: actual 0, expected 1 +122866: actual 0, expected 1 +122867: actual 0, expected 1 +122868: actual 0, expected 1 +122869: actual 0, expected 1 +122870: actual 0, expected 1 +122871: actual 0, expected 1 +122872: actual 0, expected 1 +122873: actual 0, expected 1 +122874: actual 0, expected 1 +122875: actual 0, expected 1 +122876: actual 0, expected 1 +122877: actual 0, expected 1 +122878: actual 0, expected 1 +122879: actual 0, expected 1 +7224: actual 0, expected 1 +7225: actual 0, expected 1 +7226: actual 0, expected 1 +7242: actual 0, expected 1 +7243: actual 0, expected 1 +7244: actual 0, expected 1 +6431: actual 0, expected 1 +6444: actual 0, expected 1 +6445: actual 0, expected 1 +6446: actual 0, expected 1 +6447: actual 0, expected 1 +6460: actual 0, expected 1 +6461: actual 0, expected 1 +6462: actual 0, expected 1 +6463: actual 0, expected 1 +6465: actual 0, expected 1 +6466: actual 0, expected 1 +6467: actual 0, expected 1 +67383: actual 0, expected 1 +67384: actual 0, expected 1 +67385: actual 0, expected 1 +67386: actual 0, expected 1 +67387: actual 0, expected 1 +67388: actual 0, expected 1 +67389: actual 0, expected 1 +67390: actual 0, expected 1 +67391: actual 0, expected 1 +67414: actual 0, expected 1 +67415: actual 0, expected 1 +67416: actual 0, expected 1 +67417: actual 0, expected 1 +67418: actual 0, expected 1 +67419: actual 0, expected 1 +67420: actual 0, expected 1 +67421: actual 0, expected 1 +67422: actual 0, expected 1 +67423: actual 0, expected 1 +67432: actual 0, expected 1 +67433: actual 0, expected 1 +67434: actual 0, expected 1 +67435: actual 0, expected 1 +67436: actual 0, expected 1 +67437: actual 0, expected 1 +67438: actual 0, expected 1 +67439: actual 0, expected 1 +67440: actual 0, expected 1 +67441: actual 0, expected 1 +67442: actual 0, expected 1 +67443: actual 0, expected 1 +67444: actual 0, expected 1 +67445: actual 0, expected 1 +67446: actual 0, expected 1 +67447: actual 0, expected 1 +67448: actual 0, expected 1 +67449: actual 0, expected 1 +67450: actual 0, expected 1 +67451: actual 0, expected 1 +67452: actual 0, expected 1 +67453: actual 0, expected 1 +67454: actual 0, expected 1 +67455: actual 0, expected 1 +65787: actual 0, expected 1 +65788: actual 0, expected 1 +65789: actual 0, expected 1 +65790: actual 0, expected 1 +65791: actual 0, expected 1 +65548: actual 0, expected 1 +65575: actual 0, expected 1 +65595: actual 0, expected 1 +65598: actual 0, expected 1 +65614: actual 0, expected 1 +65615: actual 0, expected 1 +65630: actual 0, expected 1 +65631: actual 0, expected 1 +65632: actual 0, expected 1 +65633: actual 0, expected 1 +65634: actual 0, expected 1 +65635: actual 0, expected 1 +65636: actual 0, expected 1 +65637: actual 0, expected 1 +65638: actual 0, expected 1 +65639: actual 0, expected 1 +65640: actual 0, expected 1 +65641: actual 0, expected 1 +65642: actual 0, expected 1 +65643: actual 0, expected 1 +65644: actual 0, expected 1 +65645: actual 0, expected 1 +65646: actual 0, expected 1 +65647: actual 0, expected 1 +65648: actual 0, expected 1 +65649: actual 0, expected 1 +65650: actual 0, expected 1 +65651: actual 0, expected 1 +65652: actual 0, expected 1 +65653: actual 0, expected 1 +65654: actual 0, expected 1 +65655: actual 0, expected 1 +65656: actual 0, expected 1 +65657: actual 0, expected 1 +65658: actual 0, expected 1 +65659: actual 0, expected 1 +65660: actual 0, expected 1 +65661: actual 0, expected 1 +65662: actual 0, expected 1 +65663: actual 0, expected 1 +73649: actual 0, expected 1 +73650: actual 0, expected 1 +73651: actual 0, expected 1 +73652: actual 0, expected 1 +73653: actual 0, expected 1 +73654: actual 0, expected 1 +73655: actual 0, expected 1 +73656: actual 0, expected 1 +73657: actual 0, expected 1 +73658: actual 0, expected 1 +73659: actual 0, expected 1 +73660: actual 0, expected 1 +73661: actual 0, expected 1 +73662: actual 0, expected 1 +73663: actual 0, expected 1 +66205: actual 0, expected 1 +66206: actual 0, expected 1 +66207: actual 0, expected 1 +67898: actual 0, expected 1 +67899: actual 0, expected 1 +67900: actual 0, expected 1 +67901: actual 0, expected 1 +67902: actual 0, expected 1 +70007: actual 0, expected 1 +70008: actual 0, expected 1 +70009: actual 0, expected 1 +70010: actual 0, expected 1 +70011: actual 0, expected 1 +70012: actual 0, expected 1 +70013: actual 0, expected 1 +70014: actual 0, expected 1 +70015: actual 0, expected 1 +127020: actual 0, expected 1 +127021: actual 0, expected 1 +127022: actual 0, expected 1 +127023: actual 0, expected 1 +73465: actual 0, expected 1 +73466: actual 0, expected 1 +73467: actual 0, expected 1 +73468: actual 0, expected 1 +73469: actual 0, expected 1 +73470: actual 0, expected 1 +73471: actual 0, expected 1 +3341: actual 0, expected 1 +3345: actual 0, expected 1 +3397: actual 0, expected 1 +3401: actual 0, expected 1 +3408: actual 0, expected 1 +3409: actual 0, expected 1 +3410: actual 0, expected 1 +3411: actual 0, expected 1 +3428: actual 0, expected 1 +3429: actual 0, expected 1 +2140: actual 0, expected 1 +2141: actual 0, expected 1 +2143: actual 0, expected 1 +68327: actual 0, expected 1 +68328: actual 0, expected 1 +68329: actual 0, expected 1 +68330: actual 0, expected 1 +68343: actual 0, expected 1 +68344: actual 0, expected 1 +68345: actual 0, expected 1 +68346: actual 0, expected 1 +68347: actual 0, expected 1 +68348: actual 0, expected 1 +68349: actual 0, expected 1 +68350: actual 0, expected 1 +68351: actual 0, expected 1 +72848: actual 0, expected 1 +72849: actual 0, expected 1 +72872: actual 0, expected 1 +72887: actual 0, expected 1 +72888: actual 0, expected 1 +72889: actual 0, expected 1 +72890: actual 0, expected 1 +72891: actual 0, expected 1 +72892: actual 0, expected 1 +72893: actual 0, expected 1 +72894: actual 0, expected 1 +72895: actual 0, expected 1 +72967: actual 0, expected 1 +72970: actual 0, expected 1 +73015: actual 0, expected 1 +73016: actual 0, expected 1 +73017: actual 0, expected 1 +73019: actual 0, expected 1 +73022: actual 0, expected 1 +73032: actual 0, expected 1 +73033: actual 0, expected 1 +73034: actual 0, expected 1 +73035: actual 0, expected 1 +73036: actual 0, expected 1 +73037: actual 0, expected 1 +73038: actual 0, expected 1 +73039: actual 0, expected 1 +73050: actual 0, expected 1 +73051: actual 0, expected 1 +73052: actual 0, expected 1 +73053: actual 0, expected 1 +73054: actual 0, expected 1 +73055: actual 0, expected 1 +119893: actual 0, expected 1 +119965: actual 0, expected 1 +119968: actual 0, expected 1 +119969: actual 0, expected 1 +119971: actual 0, expected 1 +119972: actual 0, expected 1 +119975: actual 0, expected 1 +119976: actual 0, expected 1 +119981: actual 0, expected 1 +119994: actual 0, expected 1 +119996: actual 0, expected 1 +120004: actual 0, expected 1 +120070: actual 0, expected 1 +120075: actual 0, expected 1 +120076: actual 0, expected 1 +120085: actual 0, expected 1 +120093: actual 0, expected 1 +120122: actual 0, expected 1 +120127: actual 0, expected 1 +120133: actual 0, expected 1 +120135: actual 0, expected 1 +120136: actual 0, expected 1 +120137: actual 0, expected 1 +120145: actual 0, expected 1 +120486: actual 0, expected 1 +120487: actual 0, expected 1 +120780: actual 0, expected 1 +120781: actual 0, expected 1 +119540: actual 0, expected 1 +119541: actual 0, expected 1 +119542: actual 0, expected 1 +119543: actual 0, expected 1 +119544: actual 0, expected 1 +119545: actual 0, expected 1 +119546: actual 0, expected 1 +119547: actual 0, expected 1 +119548: actual 0, expected 1 +119549: actual 0, expected 1 +119550: actual 0, expected 1 +119551: actual 0, expected 1 +93851: actual 0, expected 1 +93852: actual 0, expected 1 +93853: actual 0, expected 1 +93854: actual 0, expected 1 +93855: actual 0, expected 1 +44014: actual 0, expected 1 +44015: actual 0, expected 1 +44026: actual 0, expected 1 +44027: actual 0, expected 1 +44028: actual 0, expected 1 +44029: actual 0, expected 1 +44030: actual 0, expected 1 +44031: actual 0, expected 1 +43767: actual 0, expected 1 +43768: actual 0, expected 1 +43769: actual 0, expected 1 +43770: actual 0, expected 1 +43771: actual 0, expected 1 +43772: actual 0, expected 1 +43773: actual 0, expected 1 +43774: actual 0, expected 1 +43775: actual 0, expected 1 +125125: actual 0, expected 1 +125126: actual 0, expected 1 +125143: actual 0, expected 1 +125144: actual 0, expected 1 +125145: actual 0, expected 1 +125146: actual 0, expected 1 +125147: actual 0, expected 1 +125148: actual 0, expected 1 +125149: actual 0, expected 1 +125150: actual 0, expected 1 +125151: actual 0, expected 1 +68024: actual 0, expected 1 +68025: actual 0, expected 1 +68026: actual 0, expected 1 +68027: actual 0, expected 1 +68048: actual 0, expected 1 +68049: actual 0, expected 1 +94027: actual 0, expected 1 +94028: actual 0, expected 1 +94029: actual 0, expected 1 +94030: actual 0, expected 1 +94088: actual 0, expected 1 +94089: actual 0, expected 1 +94090: actual 0, expected 1 +94091: actual 0, expected 1 +94092: actual 0, expected 1 +94093: actual 0, expected 1 +94094: actual 0, expected 1 +11124: actual 0, expected 1 +11125: actual 0, expected 1 +11158: actual 0, expected 1 +71237: actual 0, expected 1 +71238: actual 0, expected 1 +71239: actual 0, expected 1 +71240: actual 0, expected 1 +71241: actual 0, expected 1 +71242: actual 0, expected 1 +71243: actual 0, expected 1 +71244: actual 0, expected 1 +71245: actual 0, expected 1 +71246: actual 0, expected 1 +71247: actual 0, expected 1 +71258: actual 0, expected 1 +71259: actual 0, expected 1 +71260: actual 0, expected 1 +71261: actual 0, expected 1 +71262: actual 0, expected 1 +71263: actual 0, expected 1 +6170: actual 0, expected 1 +6171: actual 0, expected 1 +6172: actual 0, expected 1 +6173: actual 0, expected 1 +6174: actual 0, expected 1 +6175: actual 0, expected 1 +6265: actual 0, expected 1 +6266: actual 0, expected 1 +6267: actual 0, expected 1 +6268: actual 0, expected 1 +6269: actual 0, expected 1 +6270: actual 0, expected 1 +6271: actual 0, expected 1 +6315: actual 0, expected 1 +6316: actual 0, expected 1 +6317: actual 0, expected 1 +6318: actual 0, expected 1 +6319: actual 0, expected 1 +71277: actual 0, expected 1 +71278: actual 0, expected 1 +71279: actual 0, expected 1 +71280: actual 0, expected 1 +71281: actual 0, expected 1 +71282: actual 0, expected 1 +71283: actual 0, expected 1 +71284: actual 0, expected 1 +71285: actual 0, expected 1 +71286: actual 0, expected 1 +71287: actual 0, expected 1 +71288: actual 0, expected 1 +71289: actual 0, expected 1 +71290: actual 0, expected 1 +71291: actual 0, expected 1 +71292: actual 0, expected 1 +71293: actual 0, expected 1 +71294: actual 0, expected 1 +71295: actual 0, expected 1 +92767: actual 0, expected 1 +92778: actual 0, expected 1 +92779: actual 0, expected 1 +92780: actual 0, expected 1 +92781: actual 0, expected 1 +70279: actual 0, expected 1 +70281: actual 0, expected 1 +70286: actual 0, expected 1 +70302: actual 0, expected 1 +70314: actual 0, expected 1 +70315: actual 0, expected 1 +70316: actual 0, expected 1 +70317: actual 0, expected 1 +70318: actual 0, expected 1 +70319: actual 0, expected 1 +119079: actual 0, expected 1 +119080: actual 0, expected 1 +119273: actual 0, expected 1 +119274: actual 0, expected 1 +119275: actual 0, expected 1 +119276: actual 0, expected 1 +119277: actual 0, expected 1 +119278: actual 0, expected 1 +119279: actual 0, expected 1 +119280: actual 0, expected 1 +119281: actual 0, expected 1 +119282: actual 0, expected 1 +119283: actual 0, expected 1 +119284: actual 0, expected 1 +119285: actual 0, expected 1 +119286: actual 0, expected 1 +119287: actual 0, expected 1 +119288: actual 0, expected 1 +119289: actual 0, expected 1 +119290: actual 0, expected 1 +119291: actual 0, expected 1 +119292: actual 0, expected 1 +119293: actual 0, expected 1 +119294: actual 0, expected 1 +119295: actual 0, expected 1 +43519: actual 0, expected 1 +67743: actual 0, expected 1 +67744: actual 0, expected 1 +67745: actual 0, expected 1 +67746: actual 0, expected 1 +67747: actual 0, expected 1 +67748: actual 0, expected 1 +67749: actual 0, expected 1 +67750: actual 0, expected 1 +72104: actual 0, expected 1 +72105: actual 0, expected 1 +72152: actual 0, expected 1 +72153: actual 0, expected 1 +72165: actual 0, expected 1 +72166: actual 0, expected 1 +72167: actual 0, expected 1 +72168: actual 0, expected 1 +72169: actual 0, expected 1 +72170: actual 0, expected 1 +72171: actual 0, expected 1 +72172: actual 0, expected 1 +72173: actual 0, expected 1 +72174: actual 0, expected 1 +72175: actual 0, expected 1 +72176: actual 0, expected 1 +72177: actual 0, expected 1 +72178: actual 0, expected 1 +72179: actual 0, expected 1 +72180: actual 0, expected 1 +72181: actual 0, expected 1 +72182: actual 0, expected 1 +72183: actual 0, expected 1 +72184: actual 0, expected 1 +72185: actual 0, expected 1 +72186: actual 0, expected 1 +72187: actual 0, expected 1 +72188: actual 0, expected 1 +72189: actual 0, expected 1 +72190: actual 0, expected 1 +72191: actual 0, expected 1 +70748: actual 0, expected 1 +70754: actual 0, expected 1 +70755: actual 0, expected 1 +70756: actual 0, expected 1 +70757: actual 0, expected 1 +70758: actual 0, expected 1 +70759: actual 0, expected 1 +70760: actual 0, expected 1 +70761: actual 0, expected 1 +70762: actual 0, expected 1 +70763: actual 0, expected 1 +70764: actual 0, expected 1 +70765: actual 0, expected 1 +70766: actual 0, expected 1 +70767: actual 0, expected 1 +70768: actual 0, expected 1 +70769: actual 0, expected 1 +70770: actual 0, expected 1 +70771: actual 0, expected 1 +70772: actual 0, expected 1 +70773: actual 0, expected 1 +70774: actual 0, expected 1 +70775: actual 0, expected 1 +70776: actual 0, expected 1 +70777: actual 0, expected 1 +70778: actual 0, expected 1 +70779: actual 0, expected 1 +70780: actual 0, expected 1 +70781: actual 0, expected 1 +70782: actual 0, expected 1 +70783: actual 0, expected 1 +6572: actual 0, expected 1 +6573: actual 0, expected 1 +6574: actual 0, expected 1 +6575: actual 0, expected 1 +6602: actual 0, expected 1 +6603: actual 0, expected 1 +6604: actual 0, expected 1 +6605: actual 0, expected 1 +6606: actual 0, expected 1 +6607: actual 0, expected 1 +6619: actual 0, expected 1 +6620: actual 0, expected 1 +6621: actual 0, expected 1 +2043: actual 0, expected 1 +2044: actual 0, expected 1 +8588: actual 0, expected 1 +8589: actual 0, expected 1 +8590: actual 0, expected 1 +8591: actual 0, expected 1 +111356: actual 0, expected 1 +111357: actual 0, expected 1 +111358: actual 0, expected 1 +111359: actual 0, expected 1 +123181: actual 0, expected 1 +123182: actual 0, expected 1 +123183: actual 0, expected 1 +123198: actual 0, expected 1 +123199: actual 0, expected 1 +123210: actual 0, expected 1 +123211: actual 0, expected 1 +123212: actual 0, expected 1 +123213: actual 0, expected 1 +5789: actual 0, expected 1 +5790: actual 0, expected 1 +5791: actual 0, expected 1 +68787: actual 0, expected 1 +68788: actual 0, expected 1 +68789: actual 0, expected 1 +68790: actual 0, expected 1 +68791: actual 0, expected 1 +68792: actual 0, expected 1 +68793: actual 0, expected 1 +68794: actual 0, expected 1 +68795: actual 0, expected 1 +68796: actual 0, expected 1 +68797: actual 0, expected 1 +68798: actual 0, expected 1 +68799: actual 0, expected 1 +68851: actual 0, expected 1 +68852: actual 0, expected 1 +68853: actual 0, expected 1 +68854: actual 0, expected 1 +68855: actual 0, expected 1 +68856: actual 0, expected 1 +68857: actual 0, expected 1 +66340: actual 0, expected 1 +66341: actual 0, expected 1 +66342: actual 0, expected 1 +66343: actual 0, expected 1 +66344: actual 0, expected 1 +66345: actual 0, expected 1 +66346: actual 0, expected 1 +66347: actual 0, expected 1 +66348: actual 0, expected 1 +66427: actual 0, expected 1 +66428: actual 0, expected 1 +66429: actual 0, expected 1 +66430: actual 0, expected 1 +66431: actual 0, expected 1 +66500: actual 0, expected 1 +66501: actual 0, expected 1 +66502: actual 0, expected 1 +66503: actual 0, expected 1 +66518: actual 0, expected 1 +66519: actual 0, expected 1 +66520: actual 0, expected 1 +66521: actual 0, expected 1 +66522: actual 0, expected 1 +66523: actual 0, expected 1 +66524: actual 0, expected 1 +66525: actual 0, expected 1 +66526: actual 0, expected 1 +66527: actual 0, expected 1 +69416: actual 0, expected 1 +69417: actual 0, expected 1 +69418: actual 0, expected 1 +69419: actual 0, expected 1 +69420: actual 0, expected 1 +69421: actual 0, expected 1 +69422: actual 0, expected 1 +69423: actual 0, expected 1 +68681: actual 0, expected 1 +68682: actual 0, expected 1 +68683: actual 0, expected 1 +68684: actual 0, expected 1 +68685: actual 0, expected 1 +68686: actual 0, expected 1 +68687: actual 0, expected 1 +69488: actual 0, expected 1 +69489: actual 0, expected 1 +69490: actual 0, expected 1 +69491: actual 0, expected 1 +69492: actual 0, expected 1 +69493: actual 0, expected 1 +69494: actual 0, expected 1 +69495: actual 0, expected 1 +69496: actual 0, expected 1 +69497: actual 0, expected 1 +69498: actual 0, expected 1 +69499: actual 0, expected 1 +69500: actual 0, expected 1 +69501: actual 0, expected 1 +69502: actual 0, expected 1 +69503: actual 0, expected 1 +69504: actual 0, expected 1 +69505: actual 0, expected 1 +69510: actual 0, expected 1 +69511: actual 0, expected 1 +69512: actual 0, expected 1 +69513: actual 0, expected 1 +69514: actual 0, expected 1 +69515: actual 0, expected 1 +69516: actual 0, expected 1 +69517: actual 0, expected 1 +69518: actual 0, expected 1 +69519: actual 0, expected 1 +69520: actual 0, expected 1 +69521: actual 0, expected 1 +69522: actual 0, expected 1 +69523: actual 0, expected 1 +69524: actual 0, expected 1 +69525: actual 0, expected 1 +69526: actual 0, expected 1 +69527: actual 0, expected 1 +69528: actual 0, expected 1 +69529: actual 0, expected 1 +69530: actual 0, expected 1 +69531: actual 0, expected 1 +69532: actual 0, expected 1 +69533: actual 0, expected 1 +69534: actual 0, expected 1 +69535: actual 0, expected 1 +69536: actual 0, expected 1 +69537: actual 0, expected 1 +69538: actual 0, expected 1 +69539: actual 0, expected 1 +69540: actual 0, expected 1 +69541: actual 0, expected 1 +69542: actual 0, expected 1 +69543: actual 0, expected 1 +69544: actual 0, expected 1 +69545: actual 0, expected 1 +69546: actual 0, expected 1 +69547: actual 0, expected 1 +69548: actual 0, expected 1 +69549: actual 0, expected 1 +69550: actual 0, expected 1 +69551: actual 0, expected 1 +9291: actual 0, expected 1 +9292: actual 0, expected 1 +9293: actual 0, expected 1 +9294: actual 0, expected 1 +9295: actual 0, expected 1 +9296: actual 0, expected 1 +9297: actual 0, expected 1 +9298: actual 0, expected 1 +9299: actual 0, expected 1 +9300: actual 0, expected 1 +9301: actual 0, expected 1 +9302: actual 0, expected 1 +9303: actual 0, expected 1 +9304: actual 0, expected 1 +9305: actual 0, expected 1 +9306: actual 0, expected 1 +9307: actual 0, expected 1 +9308: actual 0, expected 1 +9309: actual 0, expected 1 +9310: actual 0, expected 1 +9311: actual 0, expected 1 +2816: actual 0, expected 1 +2820: actual 0, expected 1 +2829: actual 0, expected 1 +2830: actual 0, expected 1 +2833: actual 0, expected 1 +2834: actual 0, expected 1 +2857: actual 0, expected 1 +2865: actual 0, expected 1 +2868: actual 0, expected 1 +2874: actual 0, expected 1 +2875: actual 0, expected 1 +2885: actual 0, expected 1 +2886: actual 0, expected 1 +2889: actual 0, expected 1 +2890: actual 0, expected 1 +2894: actual 0, expected 1 +2895: actual 0, expected 1 +2896: actual 0, expected 1 +2897: actual 0, expected 1 +2898: actual 0, expected 1 +2899: actual 0, expected 1 +2900: actual 0, expected 1 +2904: actual 0, expected 1 +2905: actual 0, expected 1 +2906: actual 0, expected 1 +2907: actual 0, expected 1 +2910: actual 0, expected 1 +2916: actual 0, expected 1 +2917: actual 0, expected 1 +2936: actual 0, expected 1 +2937: actual 0, expected 1 +2938: actual 0, expected 1 +2939: actual 0, expected 1 +2940: actual 0, expected 1 +2941: actual 0, expected 1 +2942: actual 0, expected 1 +2943: actual 0, expected 1 +66772: actual 0, expected 1 +66773: actual 0, expected 1 +66774: actual 0, expected 1 +66775: actual 0, expected 1 +66812: actual 0, expected 1 +66813: actual 0, expected 1 +66814: actual 0, expected 1 +66815: actual 0, expected 1 +66718: actual 0, expected 1 +66719: actual 0, expected 1 +66730: actual 0, expected 1 +66731: actual 0, expected 1 +66732: actual 0, expected 1 +66733: actual 0, expected 1 +66734: actual 0, expected 1 +66735: actual 0, expected 1 +126208: actual 0, expected 1 +126270: actual 0, expected 1 +126271: actual 0, expected 1 +126272: actual 0, expected 1 +126273: actual 0, expected 1 +126274: actual 0, expected 1 +126275: actual 0, expected 1 +126276: actual 0, expected 1 +126277: actual 0, expected 1 +126278: actual 0, expected 1 +126279: actual 0, expected 1 +126280: actual 0, expected 1 +126281: actual 0, expected 1 +126282: actual 0, expected 1 +126283: actual 0, expected 1 +126284: actual 0, expected 1 +126285: actual 0, expected 1 +126286: actual 0, expected 1 +126287: actual 0, expected 1 +92998: actual 0, expected 1 +92999: actual 0, expected 1 +93000: actual 0, expected 1 +93001: actual 0, expected 1 +93002: actual 0, expected 1 +93003: actual 0, expected 1 +93004: actual 0, expected 1 +93005: actual 0, expected 1 +93006: actual 0, expected 1 +93007: actual 0, expected 1 +93018: actual 0, expected 1 +93026: actual 0, expected 1 +93048: actual 0, expected 1 +93049: actual 0, expected 1 +93050: actual 0, expected 1 +93051: actual 0, expected 1 +93052: actual 0, expected 1 +72441: actual 0, expected 1 +72442: actual 0, expected 1 +72443: actual 0, expected 1 +72444: actual 0, expected 1 +72445: actual 0, expected 1 +72446: actual 0, expected 1 +72447: actual 0, expected 1 +43128: actual 0, expected 1 +43129: actual 0, expected 1 +43130: actual 0, expected 1 +43131: actual 0, expected 1 +43132: actual 0, expected 1 +43133: actual 0, expected 1 +43134: actual 0, expected 1 +43135: actual 0, expected 1 +66046: actual 0, expected 1 +66047: actual 0, expected 1 +67868: actual 0, expected 1 +67869: actual 0, expected 1 +67870: actual 0, expected 1 +127151: actual 0, expected 1 +127152: actual 0, expected 1 +127168: actual 0, expected 1 +127184: actual 0, expected 1 +127222: actual 0, expected 1 +127223: actual 0, expected 1 +127224: actual 0, expected 1 +127225: actual 0, expected 1 +127226: actual 0, expected 1 +127227: actual 0, expected 1 +127228: actual 0, expected 1 +127229: actual 0, expected 1 +127230: actual 0, expected 1 +127231: actual 0, expected 1 +68498: actual 0, expected 1 +68499: actual 0, expected 1 +68500: actual 0, expected 1 +68501: actual 0, expected 1 +68502: actual 0, expected 1 +68503: actual 0, expected 1 +68504: actual 0, expected 1 +68509: actual 0, expected 1 +68510: actual 0, expected 1 +68511: actual 0, expected 1 +68512: actual 0, expected 1 +68513: actual 0, expected 1 +68514: actual 0, expected 1 +68515: actual 0, expected 1 +68516: actual 0, expected 1 +68517: actual 0, expected 1 +68518: actual 0, expected 1 +68519: actual 0, expected 1 +68520: actual 0, expected 1 +43348: actual 0, expected 1 +43349: actual 0, expected 1 +43350: actual 0, expected 1 +43351: actual 0, expected 1 +43352: actual 0, expected 1 +43353: actual 0, expected 1 +43354: actual 0, expected 1 +43355: actual 0, expected 1 +43356: actual 0, expected 1 +43357: actual 0, expected 1 +43358: actual 0, expected 1 +69247: actual 0, expected 1 +5881: actual 0, expected 1 +5882: actual 0, expected 1 +5883: actual 0, expected 1 +5884: actual 0, expected 1 +5885: actual 0, expected 1 +5886: actual 0, expected 1 +5887: actual 0, expected 1 +2094: actual 0, expected 1 +2095: actual 0, expected 1 +2111: actual 0, expected 1 +43206: actual 0, expected 1 +43207: actual 0, expected 1 +43208: actual 0, expected 1 +43209: actual 0, expected 1 +43210: actual 0, expected 1 +43211: actual 0, expected 1 +43212: actual 0, expected 1 +43213: actual 0, expected 1 +43226: actual 0, expected 1 +43227: actual 0, expected 1 +43228: actual 0, expected 1 +43229: actual 0, expected 1 +43230: actual 0, expected 1 +43231: actual 0, expected 1 +113828: actual 0, expected 1 +113829: actual 0, expected 1 +113830: actual 0, expected 1 +113831: actual 0, expected 1 +113832: actual 0, expected 1 +113833: actual 0, expected 1 +113834: actual 0, expected 1 +113835: actual 0, expected 1 +113836: actual 0, expected 1 +113837: actual 0, expected 1 +113838: actual 0, expected 1 +113839: actual 0, expected 1 +71094: actual 0, expected 1 +71095: actual 0, expected 1 +71134: actual 0, expected 1 +71135: actual 0, expected 1 +71136: actual 0, expected 1 +71137: actual 0, expected 1 +71138: actual 0, expected 1 +71139: actual 0, expected 1 +71140: actual 0, expected 1 +71141: actual 0, expected 1 +71142: actual 0, expected 1 +71143: actual 0, expected 1 +71144: actual 0, expected 1 +71145: actual 0, expected 1 +71146: actual 0, expected 1 +71147: actual 0, expected 1 +71148: actual 0, expected 1 +71149: actual 0, expected 1 +71150: actual 0, expected 1 +71151: actual 0, expected 1 +71152: actual 0, expected 1 +71153: actual 0, expected 1 +71154: actual 0, expected 1 +71155: actual 0, expected 1 +71156: actual 0, expected 1 +71157: actual 0, expected 1 +71158: actual 0, expected 1 +71159: actual 0, expected 1 +71160: actual 0, expected 1 +71161: actual 0, expected 1 +71162: actual 0, expected 1 +71163: actual 0, expected 1 +71164: actual 0, expected 1 +71165: actual 0, expected 1 +71166: actual 0, expected 1 +71167: actual 0, expected 1 +3456: actual 0, expected 1 +3460: actual 0, expected 1 +3479: actual 0, expected 1 +3480: actual 0, expected 1 +3481: actual 0, expected 1 +3506: actual 0, expected 1 +3516: actual 0, expected 1 +3518: actual 0, expected 1 +3519: actual 0, expected 1 +3527: actual 0, expected 1 +3528: actual 0, expected 1 +3529: actual 0, expected 1 +3531: actual 0, expected 1 +3532: actual 0, expected 1 +3533: actual 0, expected 1 +3534: actual 0, expected 1 +3541: actual 0, expected 1 +3543: actual 0, expected 1 +3552: actual 0, expected 1 +3553: actual 0, expected 1 +3554: actual 0, expected 1 +3555: actual 0, expected 1 +3556: actual 0, expected 1 +3557: actual 0, expected 1 +3568: actual 0, expected 1 +3569: actual 0, expected 1 +3573: actual 0, expected 1 +3574: actual 0, expected 1 +3575: actual 0, expected 1 +3576: actual 0, expected 1 +3577: actual 0, expected 1 +3578: actual 0, expected 1 +3579: actual 0, expected 1 +3580: actual 0, expected 1 +3581: actual 0, expected 1 +3582: actual 0, expected 1 +3583: actual 0, expected 1 +70112: actual 0, expected 1 +70133: actual 0, expected 1 +70134: actual 0, expected 1 +70135: actual 0, expected 1 +70136: actual 0, expected 1 +70137: actual 0, expected 1 +70138: actual 0, expected 1 +70139: actual 0, expected 1 +70140: actual 0, expected 1 +70141: actual 0, expected 1 +70142: actual 0, expected 1 +70143: actual 0, expected 1 +65107: actual 0, expected 1 +65127: actual 0, expected 1 +65132: actual 0, expected 1 +65133: actual 0, expected 1 +65134: actual 0, expected 1 +65135: actual 0, expected 1 +110896: actual 0, expected 1 +110897: actual 0, expected 1 +110898: actual 0, expected 1 +110899: actual 0, expected 1 +110900: actual 0, expected 1 +110901: actual 0, expected 1 +110902: actual 0, expected 1 +110903: actual 0, expected 1 +110904: actual 0, expected 1 +110905: actual 0, expected 1 +110906: actual 0, expected 1 +110907: actual 0, expected 1 +110908: actual 0, expected 1 +110909: actual 0, expected 1 +110910: actual 0, expected 1 +110911: actual 0, expected 1 +110912: actual 0, expected 1 +110913: actual 0, expected 1 +110914: actual 0, expected 1 +110915: actual 0, expected 1 +110916: actual 0, expected 1 +110917: actual 0, expected 1 +110918: actual 0, expected 1 +110919: actual 0, expected 1 +110920: actual 0, expected 1 +110921: actual 0, expected 1 +110922: actual 0, expected 1 +110923: actual 0, expected 1 +110924: actual 0, expected 1 +110925: actual 0, expected 1 +110926: actual 0, expected 1 +110927: actual 0, expected 1 +110931: actual 0, expected 1 +110932: actual 0, expected 1 +110933: actual 0, expected 1 +110934: actual 0, expected 1 +110935: actual 0, expected 1 +110936: actual 0, expected 1 +110937: actual 0, expected 1 +110938: actual 0, expected 1 +110939: actual 0, expected 1 +110940: actual 0, expected 1 +110941: actual 0, expected 1 +110942: actual 0, expected 1 +110943: actual 0, expected 1 +110944: actual 0, expected 1 +110945: actual 0, expected 1 +110946: actual 0, expected 1 +110947: actual 0, expected 1 +110952: actual 0, expected 1 +110953: actual 0, expected 1 +110954: actual 0, expected 1 +110955: actual 0, expected 1 +110956: actual 0, expected 1 +110957: actual 0, expected 1 +110958: actual 0, expected 1 +110959: actual 0, expected 1 +69466: actual 0, expected 1 +69467: actual 0, expected 1 +69468: actual 0, expected 1 +69469: actual 0, expected 1 +69470: actual 0, expected 1 +69471: actual 0, expected 1 +69472: actual 0, expected 1 +69473: actual 0, expected 1 +69474: actual 0, expected 1 +69475: actual 0, expected 1 +69476: actual 0, expected 1 +69477: actual 0, expected 1 +69478: actual 0, expected 1 +69479: actual 0, expected 1 +69480: actual 0, expected 1 +69481: actual 0, expected 1 +69482: actual 0, expected 1 +69483: actual 0, expected 1 +69484: actual 0, expected 1 +69485: actual 0, expected 1 +69486: actual 0, expected 1 +69487: actual 0, expected 1 +69865: actual 0, expected 1 +69866: actual 0, expected 1 +69867: actual 0, expected 1 +69868: actual 0, expected 1 +69869: actual 0, expected 1 +69870: actual 0, expected 1 +69871: actual 0, expected 1 +69882: actual 0, expected 1 +69883: actual 0, expected 1 +69884: actual 0, expected 1 +69885: actual 0, expected 1 +69886: actual 0, expected 1 +69887: actual 0, expected 1 +72355: actual 0, expected 1 +72356: actual 0, expected 1 +72357: actual 0, expected 1 +72358: actual 0, expected 1 +72359: actual 0, expected 1 +72360: actual 0, expected 1 +72361: actual 0, expected 1 +72362: actual 0, expected 1 +72363: actual 0, expected 1 +72364: actual 0, expected 1 +72365: actual 0, expected 1 +72366: actual 0, expected 1 +72367: actual 0, expected 1 +65520: actual 0, expected 1 +65521: actual 0, expected 1 +65522: actual 0, expected 1 +65523: actual 0, expected 1 +65524: actual 0, expected 1 +65525: actual 0, expected 1 +65526: actual 0, expected 1 +65527: actual 0, expected 1 +65528: actual 0, expected 1 +65534: actual 0, expected 1 +65535: actual 0, expected 1 +7368: actual 0, expected 1 +7369: actual 0, expected 1 +7370: actual 0, expected 1 +7371: actual 0, expected 1 +7372: actual 0, expected 1 +7373: actual 0, expected 1 +7374: actual 0, expected 1 +7375: actual 0, expected 1 +8306: actual 0, expected 1 +8307: actual 0, expected 1 +8335: actual 0, expected 1 +8349: actual 0, expected 1 +8350: actual 0, expected 1 +8351: actual 0, expected 1 +129036: actual 0, expected 1 +129037: actual 0, expected 1 +129038: actual 0, expected 1 +129039: actual 0, expected 1 +129096: actual 0, expected 1 +129097: actual 0, expected 1 +129098: actual 0, expected 1 +129099: actual 0, expected 1 +129100: actual 0, expected 1 +129101: actual 0, expected 1 +129102: actual 0, expected 1 +129103: actual 0, expected 1 +129114: actual 0, expected 1 +129115: actual 0, expected 1 +129116: actual 0, expected 1 +129117: actual 0, expected 1 +129118: actual 0, expected 1 +129119: actual 0, expected 1 +129160: actual 0, expected 1 +129161: actual 0, expected 1 +129162: actual 0, expected 1 +129163: actual 0, expected 1 +129164: actual 0, expected 1 +129165: actual 0, expected 1 +129166: actual 0, expected 1 +129167: actual 0, expected 1 +129198: actual 0, expected 1 +129199: actual 0, expected 1 +129202: actual 0, expected 1 +129203: actual 0, expected 1 +129204: actual 0, expected 1 +129205: actual 0, expected 1 +129206: actual 0, expected 1 +129207: actual 0, expected 1 +129208: actual 0, expected 1 +129209: actual 0, expected 1 +129210: actual 0, expected 1 +129211: actual 0, expected 1 +129212: actual 0, expected 1 +129213: actual 0, expected 1 +129214: actual 0, expected 1 +129215: actual 0, expected 1 +129216: actual 0, expected 1 +129217: actual 0, expected 1 +129218: actual 0, expected 1 +129219: actual 0, expected 1 +129220: actual 0, expected 1 +129221: actual 0, expected 1 +129222: actual 0, expected 1 +129223: actual 0, expected 1 +129224: actual 0, expected 1 +129225: actual 0, expected 1 +129226: actual 0, expected 1 +129227: actual 0, expected 1 +129228: actual 0, expected 1 +129229: actual 0, expected 1 +129230: actual 0, expected 1 +129231: actual 0, expected 1 +129232: actual 0, expected 1 +129233: actual 0, expected 1 +129234: actual 0, expected 1 +129235: actual 0, expected 1 +129236: actual 0, expected 1 +129237: actual 0, expected 1 +129238: actual 0, expected 1 +129239: actual 0, expected 1 +129240: actual 0, expected 1 +129241: actual 0, expected 1 +129242: actual 0, expected 1 +129243: actual 0, expected 1 +129244: actual 0, expected 1 +129245: actual 0, expected 1 +129246: actual 0, expected 1 +129247: actual 0, expected 1 +129248: actual 0, expected 1 +129249: actual 0, expected 1 +129250: actual 0, expected 1 +129251: actual 0, expected 1 +129252: actual 0, expected 1 +129253: actual 0, expected 1 +129254: actual 0, expected 1 +129255: actual 0, expected 1 +129256: actual 0, expected 1 +129257: actual 0, expected 1 +129258: actual 0, expected 1 +129259: actual 0, expected 1 +129260: actual 0, expected 1 +129261: actual 0, expected 1 +129262: actual 0, expected 1 +129263: actual 0, expected 1 +129264: actual 0, expected 1 +129265: actual 0, expected 1 +129266: actual 0, expected 1 +129267: actual 0, expected 1 +129268: actual 0, expected 1 +129269: actual 0, expected 1 +129270: actual 0, expected 1 +129271: actual 0, expected 1 +129272: actual 0, expected 1 +129273: actual 0, expected 1 +129274: actual 0, expected 1 +129275: actual 0, expected 1 +129276: actual 0, expected 1 +129277: actual 0, expected 1 +129278: actual 0, expected 1 +129279: actual 0, expected 1 +11859: actual 0, expected 1 +11860: actual 0, expected 1 +11861: actual 0, expected 1 +11862: actual 0, expected 1 +11863: actual 0, expected 1 +11864: actual 0, expected 1 +11865: actual 0, expected 1 +11866: actual 0, expected 1 +11867: actual 0, expected 1 +11868: actual 0, expected 1 +11869: actual 0, expected 1 +11870: actual 0, expected 1 +11871: actual 0, expected 1 +11872: actual 0, expected 1 +11873: actual 0, expected 1 +11874: actual 0, expected 1 +11875: actual 0, expected 1 +11876: actual 0, expected 1 +11877: actual 0, expected 1 +11878: actual 0, expected 1 +11879: actual 0, expected 1 +11880: actual 0, expected 1 +11881: actual 0, expected 1 +11882: actual 0, expected 1 +11883: actual 0, expected 1 +11884: actual 0, expected 1 +11885: actual 0, expected 1 +11886: actual 0, expected 1 +11887: actual 0, expected 1 +11888: actual 0, expected 1 +11889: actual 0, expected 1 +11890: actual 0, expected 1 +11891: actual 0, expected 1 +11892: actual 0, expected 1 +11893: actual 0, expected 1 +11894: actual 0, expected 1 +11895: actual 0, expected 1 +11896: actual 0, expected 1 +11897: actual 0, expected 1 +11898: actual 0, expected 1 +11899: actual 0, expected 1 +11900: actual 0, expected 1 +11901: actual 0, expected 1 +11902: actual 0, expected 1 +11903: actual 0, expected 1 +129401: actual 0, expected 2 +129484: actual 0, expected 2 +1048574: actual 0, expected 1 +1048575: actual 0, expected 1 +1114110: actual 0, expected 1 +1114111: actual 0, expected 1 +121484: actual 0, expected 1 +121485: actual 0, expected 1 +121486: actual 0, expected 1 +121487: actual 0, expected 1 +121488: actual 0, expected 1 +121489: actual 0, expected 1 +121490: actual 0, expected 1 +121491: actual 0, expected 1 +121492: actual 0, expected 1 +121493: actual 0, expected 1 +121494: actual 0, expected 1 +121495: actual 0, expected 1 +121496: actual 0, expected 1 +121497: actual 0, expected 1 +121498: actual 0, expected 1 +121504: actual 0, expected 1 +43053: actual 0, expected 1 +43054: actual 0, expected 1 +43055: actual 0, expected 1 +129653: actual 0, expected 1 +129654: actual 0, expected 1 +129655: actual 0, expected 1 +129659: actual 0, expected 2 +129660: actual 0, expected 2 +129661: actual 0, expected 1 +129662: actual 0, expected 1 +129663: actual 0, expected 1 +129671: actual 0, expected 1 +129672: actual 0, expected 1 +129673: actual 0, expected 1 +129674: actual 0, expected 1 +129675: actual 0, expected 1 +129676: actual 0, expected 1 +129677: actual 0, expected 1 +129678: actual 0, expected 1 +129679: actual 0, expected 1 +129705: actual 0, expected 2 +129706: actual 0, expected 2 +129707: actual 0, expected 2 +129708: actual 0, expected 2 +129709: actual 0, expected 1 +129710: actual 0, expected 1 +129711: actual 0, expected 1 +129719: actual 0, expected 2 +129720: actual 0, expected 2 +129721: actual 0, expected 2 +129722: actual 0, expected 2 +129723: actual 0, expected 1 +129724: actual 0, expected 1 +129725: actual 0, expected 1 +129726: actual 0, expected 1 +129727: actual 0, expected 1 +129731: actual 0, expected 2 +129732: actual 0, expected 2 +129733: actual 0, expected 2 +129734: actual 0, expected 1 +129735: actual 0, expected 1 +129736: actual 0, expected 1 +129737: actual 0, expected 1 +129738: actual 0, expected 1 +129739: actual 0, expected 1 +129740: actual 0, expected 1 +129741: actual 0, expected 1 +129742: actual 0, expected 1 +129743: actual 0, expected 1 +129751: actual 0, expected 2 +129752: actual 0, expected 2 +129753: actual 0, expected 2 +129754: actual 0, expected 1 +129755: actual 0, expected 1 +129756: actual 0, expected 1 +129757: actual 0, expected 1 +129758: actual 0, expected 1 +129759: actual 0, expected 1 +129760: actual 0, expected 2 +129761: actual 0, expected 2 +129762: actual 0, expected 2 +129763: actual 0, expected 2 +129764: actual 0, expected 2 +129765: actual 0, expected 2 +129766: actual 0, expected 2 +129767: actual 0, expected 2 +129768: actual 0, expected 1 +129769: actual 0, expected 1 +129770: actual 0, expected 1 +129771: actual 0, expected 1 +129772: actual 0, expected 1 +129773: actual 0, expected 1 +129774: actual 0, expected 1 +129775: actual 0, expected 1 +129776: actual 0, expected 2 +129777: actual 0, expected 2 +129778: actual 0, expected 2 +129779: actual 0, expected 2 +129780: actual 0, expected 2 +129781: actual 0, expected 2 +129782: actual 0, expected 2 +129783: actual 0, expected 1 +129784: actual 0, expected 1 +129785: actual 0, expected 1 +129786: actual 0, expected 1 +129787: actual 0, expected 1 +129788: actual 0, expected 1 +129789: actual 0, expected 1 +129790: actual 0, expected 1 +129791: actual 0, expected 1 +129939: actual 0, expected 1 +129995: actual 0, expected 1 +129996: actual 0, expected 1 +129997: actual 0, expected 1 +129998: actual 0, expected 1 +129999: actual 0, expected 1 +130000: actual 0, expected 1 +130001: actual 0, expected 1 +130002: actual 0, expected 1 +130003: actual 0, expected 1 +130004: actual 0, expected 1 +130005: actual 0, expected 1 +130006: actual 0, expected 1 +130007: actual 0, expected 1 +130008: actual 0, expected 1 +130009: actual 0, expected 1 +130010: actual 0, expected 1 +130011: actual 0, expected 1 +130012: actual 0, expected 1 +130013: actual 0, expected 1 +130014: actual 0, expected 1 +130015: actual 0, expected 1 +130016: actual 0, expected 1 +130017: actual 0, expected 1 +130018: actual 0, expected 1 +130019: actual 0, expected 1 +130020: actual 0, expected 1 +130021: actual 0, expected 1 +130022: actual 0, expected 1 +130023: actual 0, expected 1 +130024: actual 0, expected 1 +130025: actual 0, expected 1 +130026: actual 0, expected 1 +130027: actual 0, expected 1 +130028: actual 0, expected 1 +130029: actual 0, expected 1 +130030: actual 0, expected 1 +130031: actual 0, expected 1 +130042: actual 0, expected 1 +130043: actual 0, expected 1 +130044: actual 0, expected 1 +130045: actual 0, expected 1 +130046: actual 0, expected 1 +130047: actual 0, expected 1 +1806: actual 0, expected 1 +1807: actual 1, expected 0 +1867: actual 0, expected 1 +1868: actual 0, expected 1 +2155: actual 0, expected 1 +2156: actual 0, expected 1 +2157: actual 0, expected 1 +2158: actual 0, expected 1 +2159: actual 0, expected 1 +5901: actual 0, expected 1 +5909: actual 0, expected 1 +5910: actual 0, expected 1 +5911: actual 0, expected 1 +5912: actual 0, expected 1 +5913: actual 0, expected 1 +5914: actual 0, expected 1 +5915: actual 0, expected 1 +5916: actual 0, expected 1 +5917: actual 0, expected 1 +5918: actual 0, expected 1 +5919: actual 0, expected 1 +5997: actual 0, expected 1 +6001: actual 0, expected 1 +6004: actual 0, expected 1 +6005: actual 0, expected 1 +6006: actual 0, expected 1 +6007: actual 0, expected 1 +6008: actual 0, expected 1 +6009: actual 0, expected 1 +6010: actual 0, expected 1 +6011: actual 0, expected 1 +6012: actual 0, expected 1 +6013: actual 0, expected 1 +6014: actual 0, expected 1 +6015: actual 0, expected 1 +917504: actual 0, expected 1 +917506: actual 0, expected 1 +917507: actual 0, expected 1 +917508: actual 0, expected 1 +917509: actual 0, expected 1 +917510: actual 0, expected 1 +917511: actual 0, expected 1 +917512: actual 0, expected 1 +917513: actual 0, expected 1 +917514: actual 0, expected 1 +917515: actual 0, expected 1 +917516: actual 0, expected 1 +917517: actual 0, expected 1 +917518: actual 0, expected 1 +917519: actual 0, expected 1 +917520: actual 0, expected 1 +917521: actual 0, expected 1 +917522: actual 0, expected 1 +917523: actual 0, expected 1 +917524: actual 0, expected 1 +917525: actual 0, expected 1 +917526: actual 0, expected 1 +917527: actual 0, expected 1 +917528: actual 0, expected 1 +917529: actual 0, expected 1 +917530: actual 0, expected 1 +917531: actual 0, expected 1 +917532: actual 0, expected 1 +917533: actual 0, expected 1 +917534: actual 0, expected 1 +917535: actual 0, expected 1 +6510: actual 0, expected 1 +6511: actual 0, expected 1 +6517: actual 0, expected 1 +6518: actual 0, expected 1 +6519: actual 0, expected 1 +6520: actual 0, expected 1 +6521: actual 0, expected 1 +6522: actual 0, expected 1 +6523: actual 0, expected 1 +6524: actual 0, expected 1 +6525: actual 0, expected 1 +6526: actual 0, expected 1 +6527: actual 0, expected 1 +6751: actual 0, expected 1 +6781: actual 0, expected 1 +6782: actual 0, expected 1 +6794: actual 0, expected 1 +6795: actual 0, expected 1 +6796: actual 0, expected 1 +6797: actual 0, expected 1 +6798: actual 0, expected 1 +6799: actual 0, expected 1 +6810: actual 0, expected 1 +6811: actual 0, expected 1 +6812: actual 0, expected 1 +6813: actual 0, expected 1 +6814: actual 0, expected 1 +6815: actual 0, expected 1 +6830: actual 0, expected 1 +6831: actual 0, expected 1 +43715: actual 0, expected 1 +43716: actual 0, expected 1 +43717: actual 0, expected 1 +43718: actual 0, expected 1 +43719: actual 0, expected 1 +43720: actual 0, expected 1 +43721: actual 0, expected 1 +43722: actual 0, expected 1 +43723: actual 0, expected 1 +43724: actual 0, expected 1 +43725: actual 0, expected 1 +43726: actual 0, expected 1 +43727: actual 0, expected 1 +43728: actual 0, expected 1 +43729: actual 0, expected 1 +43730: actual 0, expected 1 +43731: actual 0, expected 1 +43732: actual 0, expected 1 +43733: actual 0, expected 1 +43734: actual 0, expected 1 +43735: actual 0, expected 1 +43736: actual 0, expected 1 +43737: actual 0, expected 1 +43738: actual 0, expected 1 +119639: actual 0, expected 1 +119640: actual 0, expected 1 +119641: actual 0, expected 1 +119642: actual 0, expected 1 +119643: actual 0, expected 1 +119644: actual 0, expected 1 +119645: actual 0, expected 1 +119646: actual 0, expected 1 +119647: actual 0, expected 1 +71353: actual 0, expected 1 +71354: actual 0, expected 1 +71355: actual 0, expected 1 +71356: actual 0, expected 1 +71357: actual 0, expected 1 +71358: actual 0, expected 1 +71359: actual 0, expected 1 +71370: actual 0, expected 1 +71371: actual 0, expected 1 +71372: actual 0, expected 1 +71373: actual 0, expected 1 +71374: actual 0, expected 1 +71375: actual 0, expected 1 +2944: actual 0, expected 1 +2945: actual 0, expected 1 +2948: actual 0, expected 1 +2955: actual 0, expected 1 +2956: actual 0, expected 1 +2957: actual 0, expected 1 +2961: actual 0, expected 1 +2966: actual 0, expected 1 +2967: actual 0, expected 1 +2968: actual 0, expected 1 +2971: actual 0, expected 1 +2973: actual 0, expected 1 +2976: actual 0, expected 1 +2977: actual 0, expected 1 +2978: actual 0, expected 1 +2981: actual 0, expected 1 +2982: actual 0, expected 1 +2983: actual 0, expected 1 +2987: actual 0, expected 1 +2988: actual 0, expected 1 +2989: actual 0, expected 1 +3002: actual 0, expected 1 +3003: actual 0, expected 1 +3004: actual 0, expected 1 +3005: actual 0, expected 1 +3011: actual 0, expected 1 +3012: actual 0, expected 1 +3013: actual 0, expected 1 +3017: actual 0, expected 1 +3022: actual 0, expected 1 +3023: actual 0, expected 1 +3025: actual 0, expected 1 +3026: actual 0, expected 1 +3027: actual 0, expected 1 +3028: actual 0, expected 1 +3029: actual 0, expected 1 +3030: actual 0, expected 1 +3032: actual 0, expected 1 +3033: actual 0, expected 1 +3034: actual 0, expected 1 +3035: actual 0, expected 1 +3036: actual 0, expected 1 +3037: actual 0, expected 1 +3038: actual 0, expected 1 +3039: actual 0, expected 1 +3040: actual 0, expected 1 +3041: actual 0, expected 1 +3042: actual 0, expected 1 +3043: actual 0, expected 1 +3044: actual 0, expected 1 +3045: actual 0, expected 1 +3067: actual 0, expected 1 +3068: actual 0, expected 1 +3069: actual 0, expected 1 +3070: actual 0, expected 1 +3071: actual 0, expected 1 +73714: actual 0, expected 1 +73715: actual 0, expected 1 +73716: actual 0, expected 1 +73717: actual 0, expected 1 +73718: actual 0, expected 1 +73719: actual 0, expected 1 +73720: actual 0, expected 1 +73721: actual 0, expected 1 +73722: actual 0, expected 1 +73723: actual 0, expected 1 +73724: actual 0, expected 1 +73725: actual 0, expected 1 +73726: actual 0, expected 1 +92784: actual 0, expected 1 +92785: actual 0, expected 1 +92786: actual 0, expected 1 +92787: actual 0, expected 1 +92788: actual 0, expected 1 +92789: actual 0, expected 1 +92790: actual 0, expected 1 +92791: actual 0, expected 1 +92792: actual 0, expected 1 +92793: actual 0, expected 1 +92794: actual 0, expected 1 +92795: actual 0, expected 1 +92796: actual 0, expected 1 +92797: actual 0, expected 1 +92798: actual 0, expected 1 +92799: actual 0, expected 1 +92800: actual 0, expected 1 +92801: actual 0, expected 1 +92802: actual 0, expected 1 +92803: actual 0, expected 1 +92804: actual 0, expected 1 +92805: actual 0, expected 1 +92806: actual 0, expected 1 +92807: actual 0, expected 1 +92808: actual 0, expected 1 +92809: actual 0, expected 1 +92810: actual 0, expected 1 +92811: actual 0, expected 1 +92812: actual 0, expected 1 +92813: actual 0, expected 1 +92814: actual 0, expected 1 +92815: actual 0, expected 1 +92816: actual 0, expected 1 +92817: actual 0, expected 1 +92818: actual 0, expected 1 +92819: actual 0, expected 1 +92820: actual 0, expected 1 +92821: actual 0, expected 1 +92822: actual 0, expected 1 +92823: actual 0, expected 1 +92824: actual 0, expected 1 +92825: actual 0, expected 1 +92826: actual 0, expected 1 +92827: actual 0, expected 1 +92828: actual 0, expected 1 +92829: actual 0, expected 1 +92830: actual 0, expected 1 +92831: actual 0, expected 1 +92832: actual 0, expected 1 +92833: actual 0, expected 1 +92834: actual 0, expected 1 +92835: actual 0, expected 1 +92836: actual 0, expected 1 +92837: actual 0, expected 1 +92838: actual 0, expected 1 +92839: actual 0, expected 1 +92840: actual 0, expected 1 +92841: actual 0, expected 1 +92842: actual 0, expected 1 +92843: actual 0, expected 1 +92844: actual 0, expected 1 +92845: actual 0, expected 1 +92846: actual 0, expected 1 +92847: actual 0, expected 1 +92848: actual 0, expected 1 +92849: actual 0, expected 1 +92850: actual 0, expected 1 +92851: actual 0, expected 1 +92852: actual 0, expected 1 +92853: actual 0, expected 1 +92854: actual 0, expected 1 +92855: actual 0, expected 1 +92856: actual 0, expected 1 +92857: actual 0, expected 1 +92858: actual 0, expected 1 +92859: actual 0, expected 1 +92860: actual 0, expected 1 +92861: actual 0, expected 1 +92862: actual 0, expected 1 +92863: actual 0, expected 1 +92864: actual 0, expected 1 +92865: actual 0, expected 1 +92866: actual 0, expected 1 +92867: actual 0, expected 1 +92868: actual 0, expected 1 +92869: actual 0, expected 1 +92870: actual 0, expected 1 +92871: actual 0, expected 1 +92872: actual 0, expected 1 +92873: actual 0, expected 1 +92874: actual 0, expected 1 +92875: actual 0, expected 1 +92876: actual 0, expected 1 +92877: actual 0, expected 1 +92878: actual 0, expected 1 +92879: actual 0, expected 1 +100344: actual 0, expected 1 +100345: actual 0, expected 1 +100346: actual 0, expected 1 +100347: actual 0, expected 1 +100348: actual 0, expected 1 +100349: actual 0, expected 1 +100350: actual 0, expected 1 +100351: actual 0, expected 1 +101641: actual 0, expected 1 +101642: actual 0, expected 1 +101643: actual 0, expected 1 +101644: actual 0, expected 1 +101645: actual 0, expected 1 +101646: actual 0, expected 1 +101647: actual 0, expected 1 +101648: actual 0, expected 1 +101649: actual 0, expected 1 +101650: actual 0, expected 1 +101651: actual 0, expected 1 +101652: actual 0, expected 1 +101653: actual 0, expected 1 +101654: actual 0, expected 1 +101655: actual 0, expected 1 +101656: actual 0, expected 1 +101657: actual 0, expected 1 +101658: actual 0, expected 1 +101659: actual 0, expected 1 +101660: actual 0, expected 1 +101661: actual 0, expected 1 +101662: actual 0, expected 1 +101663: actual 0, expected 1 +101664: actual 0, expected 1 +101665: actual 0, expected 1 +101666: actual 0, expected 1 +101667: actual 0, expected 1 +101668: actual 0, expected 1 +101669: actual 0, expected 1 +101670: actual 0, expected 1 +101671: actual 0, expected 1 +101672: actual 0, expected 1 +101673: actual 0, expected 1 +101674: actual 0, expected 1 +101675: actual 0, expected 1 +101676: actual 0, expected 1 +101677: actual 0, expected 1 +101678: actual 0, expected 1 +101679: actual 0, expected 1 +101680: actual 0, expected 1 +101681: actual 0, expected 1 +101682: actual 0, expected 1 +101683: actual 0, expected 1 +101684: actual 0, expected 1 +101685: actual 0, expected 1 +101686: actual 0, expected 1 +101687: actual 0, expected 1 +101688: actual 0, expected 1 +101689: actual 0, expected 1 +101690: actual 0, expected 1 +101691: actual 0, expected 1 +101692: actual 0, expected 1 +101693: actual 0, expected 1 +101694: actual 0, expected 1 +101695: actual 0, expected 1 +101696: actual 0, expected 1 +101697: actual 0, expected 1 +101698: actual 0, expected 1 +101699: actual 0, expected 1 +101700: actual 0, expected 1 +101701: actual 0, expected 1 +101702: actual 0, expected 1 +101703: actual 0, expected 1 +101704: actual 0, expected 1 +101705: actual 0, expected 1 +101706: actual 0, expected 1 +101707: actual 0, expected 1 +101708: actual 0, expected 1 +101709: actual 0, expected 1 +101710: actual 0, expected 1 +101711: actual 0, expected 1 +101712: actual 0, expected 1 +101713: actual 0, expected 1 +101714: actual 0, expected 1 +101715: actual 0, expected 1 +101716: actual 0, expected 1 +101717: actual 0, expected 1 +101718: actual 0, expected 1 +101719: actual 0, expected 1 +101720: actual 0, expected 1 +101721: actual 0, expected 1 +101722: actual 0, expected 1 +101723: actual 0, expected 1 +101724: actual 0, expected 1 +101725: actual 0, expected 1 +101726: actual 0, expected 1 +101727: actual 0, expected 1 +101728: actual 0, expected 1 +101729: actual 0, expected 1 +101730: actual 0, expected 1 +101731: actual 0, expected 1 +101732: actual 0, expected 1 +101733: actual 0, expected 1 +101734: actual 0, expected 1 +101735: actual 0, expected 1 +101736: actual 0, expected 1 +101737: actual 0, expected 1 +101738: actual 0, expected 1 +101739: actual 0, expected 1 +101740: actual 0, expected 1 +101741: actual 0, expected 1 +101742: actual 0, expected 1 +101743: actual 0, expected 1 +101744: actual 0, expected 1 +101745: actual 0, expected 1 +101746: actual 0, expected 1 +101747: actual 0, expected 1 +101748: actual 0, expected 1 +101749: actual 0, expected 1 +101750: actual 0, expected 1 +101751: actual 0, expected 1 +101752: actual 0, expected 1 +101753: actual 0, expected 1 +101754: actual 0, expected 1 +101755: actual 0, expected 1 +101756: actual 0, expected 1 +101757: actual 0, expected 1 +101758: actual 0, expected 1 +101759: actual 0, expected 1 +3085: actual 0, expected 1 +3089: actual 0, expected 1 +3113: actual 0, expected 1 +3130: actual 0, expected 1 +3131: actual 0, expected 1 +3141: actual 0, expected 1 +3145: actual 0, expected 1 +3150: actual 0, expected 1 +3151: actual 0, expected 1 +3152: actual 0, expected 1 +3153: actual 0, expected 1 +3154: actual 0, expected 1 +3155: actual 0, expected 1 +3156: actual 0, expected 1 +3159: actual 0, expected 1 +3163: actual 0, expected 1 +3164: actual 0, expected 1 +3165: actual 0, expected 1 +3166: actual 0, expected 1 +3167: actual 0, expected 1 +3172: actual 0, expected 1 +3173: actual 0, expected 1 +3184: actual 0, expected 1 +3185: actual 0, expected 1 +3186: actual 0, expected 1 +3187: actual 0, expected 1 +3188: actual 0, expected 1 +3189: actual 0, expected 1 +3190: actual 0, expected 1 +1970: actual 0, expected 1 +1971: actual 0, expected 1 +1972: actual 0, expected 1 +1973: actual 0, expected 1 +1974: actual 0, expected 1 +1975: actual 0, expected 1 +1976: actual 0, expected 1 +1977: actual 0, expected 1 +1978: actual 0, expected 1 +1979: actual 0, expected 1 +1980: actual 0, expected 1 +1981: actual 0, expected 1 +1982: actual 0, expected 1 +1983: actual 0, expected 1 +3584: actual 0, expected 1 +3643: actual 0, expected 1 +3644: actual 0, expected 1 +3645: actual 0, expected 1 +3646: actual 0, expected 1 +3676: actual 0, expected 1 +3677: actual 0, expected 1 +3678: actual 0, expected 1 +3679: actual 0, expected 1 +3680: actual 0, expected 1 +3681: actual 0, expected 1 +3682: actual 0, expected 1 +3683: actual 0, expected 1 +3684: actual 0, expected 1 +3685: actual 0, expected 1 +3686: actual 0, expected 1 +3687: actual 0, expected 1 +3688: actual 0, expected 1 +3689: actual 0, expected 1 +3690: actual 0, expected 1 +3691: actual 0, expected 1 +3692: actual 0, expected 1 +3693: actual 0, expected 1 +3694: actual 0, expected 1 +3695: actual 0, expected 1 +3696: actual 0, expected 1 +3697: actual 0, expected 1 +3698: actual 0, expected 1 +3699: actual 0, expected 1 +3700: actual 0, expected 1 +3701: actual 0, expected 1 +3702: actual 0, expected 1 +3703: actual 0, expected 1 +3704: actual 0, expected 1 +3705: actual 0, expected 1 +3706: actual 0, expected 1 +3707: actual 0, expected 1 +3708: actual 0, expected 1 +3709: actual 0, expected 1 +3710: actual 0, expected 1 +3711: actual 0, expected 1 +3912: actual 0, expected 1 +3949: actual 0, expected 1 +3950: actual 0, expected 1 +3951: actual 0, expected 1 +3952: actual 0, expected 1 +3992: actual 0, expected 1 +4029: actual 0, expected 1 +4045: actual 0, expected 1 +4059: actual 0, expected 1 +4060: actual 0, expected 1 +4061: actual 0, expected 1 +4062: actual 0, expected 1 +4063: actual 0, expected 1 +4064: actual 0, expected 1 +4065: actual 0, expected 1 +4066: actual 0, expected 1 +4067: actual 0, expected 1 +4068: actual 0, expected 1 +4069: actual 0, expected 1 +4070: actual 0, expected 1 +4071: actual 0, expected 1 +4072: actual 0, expected 1 +4073: actual 0, expected 1 +4074: actual 0, expected 1 +4075: actual 0, expected 1 +4076: actual 0, expected 1 +4077: actual 0, expected 1 +4078: actual 0, expected 1 +4079: actual 0, expected 1 +4080: actual 0, expected 1 +4081: actual 0, expected 1 +4082: actual 0, expected 1 +4083: actual 0, expected 1 +4084: actual 0, expected 1 +4085: actual 0, expected 1 +4086: actual 0, expected 1 +4087: actual 0, expected 1 +4088: actual 0, expected 1 +4089: actual 0, expected 1 +4090: actual 0, expected 1 +4091: actual 0, expected 1 +4092: actual 0, expected 1 +4093: actual 0, expected 1 +4094: actual 0, expected 1 +4095: actual 0, expected 1 +11624: actual 0, expected 1 +11625: actual 0, expected 1 +11626: actual 0, expected 1 +11627: actual 0, expected 1 +11628: actual 0, expected 1 +11629: actual 0, expected 1 +11630: actual 0, expected 1 +11633: actual 0, expected 1 +11634: actual 0, expected 1 +11635: actual 0, expected 1 +11636: actual 0, expected 1 +11637: actual 0, expected 1 +11638: actual 0, expected 1 +11639: actual 0, expected 1 +11640: actual 0, expected 1 +11641: actual 0, expected 1 +11642: actual 0, expected 1 +11643: actual 0, expected 1 +11644: actual 0, expected 1 +11645: actual 0, expected 1 +11646: actual 0, expected 1 +70856: actual 0, expected 1 +70857: actual 0, expected 1 +70858: actual 0, expected 1 +70859: actual 0, expected 1 +70860: actual 0, expected 1 +70861: actual 0, expected 1 +70862: actual 0, expected 1 +70863: actual 0, expected 1 +70874: actual 0, expected 1 +70875: actual 0, expected 1 +70876: actual 0, expected 1 +70877: actual 0, expected 1 +70878: actual 0, expected 1 +70879: actual 0, expected 1 +123536: actual 0, expected 1 +123537: actual 0, expected 1 +123538: actual 0, expected 1 +123539: actual 0, expected 1 +123540: actual 0, expected 1 +123541: actual 0, expected 1 +123542: actual 0, expected 1 +123543: actual 0, expected 1 +123544: actual 0, expected 1 +123545: actual 0, expected 1 +123546: actual 0, expected 1 +123547: actual 0, expected 1 +123548: actual 0, expected 1 +123549: actual 0, expected 1 +123550: actual 0, expected 1 +123551: actual 0, expected 1 +123552: actual 0, expected 1 +123553: actual 0, expected 1 +123554: actual 0, expected 1 +123555: actual 0, expected 1 +123556: actual 0, expected 1 +123557: actual 0, expected 1 +123558: actual 0, expected 1 +123559: actual 0, expected 1 +123560: actual 0, expected 1 +123561: actual 0, expected 1 +123562: actual 0, expected 1 +123563: actual 0, expected 1 +123564: actual 0, expected 1 +123565: actual 0, expected 1 +123567: actual 0, expected 1 +123568: actual 0, expected 1 +123569: actual 0, expected 1 +123570: actual 0, expected 1 +123571: actual 0, expected 1 +123572: actual 0, expected 1 +123573: actual 0, expected 1 +123574: actual 0, expected 1 +123575: actual 0, expected 1 +123576: actual 0, expected 1 +123577: actual 0, expected 1 +123578: actual 0, expected 1 +123579: actual 0, expected 1 +123580: actual 0, expected 1 +123581: actual 0, expected 1 +123582: actual 0, expected 1 +123583: actual 0, expected 1 +128728: actual 0, expected 1 +128729: actual 0, expected 1 +128730: actual 0, expected 1 +128731: actual 0, expected 1 +128732: actual 0, expected 1 +128733: actual 0, expected 2 +128734: actual 0, expected 2 +128735: actual 0, expected 2 +128749: actual 0, expected 1 +128750: actual 0, expected 1 +128751: actual 0, expected 1 +128765: actual 0, expected 1 +128766: actual 0, expected 1 +128767: actual 0, expected 1 +66462: actual 0, expected 1 +6390: actual 0, expected 1 +6391: actual 0, expected 1 +6392: actual 0, expected 1 +6393: actual 0, expected 1 +6394: actual 0, expected 1 +6395: actual 0, expected 1 +6396: actual 0, expected 1 +6397: actual 0, expected 1 +6398: actual 0, expected 1 +6399: actual 0, expected 1 +72368: actual 0, expected 1 +72369: actual 0, expected 1 +72370: actual 0, expected 1 +72371: actual 0, expected 1 +72372: actual 0, expected 1 +72373: actual 0, expected 1 +72374: actual 0, expected 1 +72375: actual 0, expected 1 +72376: actual 0, expected 1 +72377: actual 0, expected 1 +72378: actual 0, expected 1 +72379: actual 0, expected 1 +72380: actual 0, expected 1 +72381: actual 0, expected 1 +72382: actual 0, expected 1 +72383: actual 0, expected 1 +42540: actual 0, expected 1 +42541: actual 0, expected 1 +42542: actual 0, expected 1 +42543: actual 0, expected 1 +42544: actual 0, expected 1 +42545: actual 0, expected 1 +42546: actual 0, expected 1 +42547: actual 0, expected 1 +42548: actual 0, expected 1 +42549: actual 0, expected 1 +42550: actual 0, expected 1 +42551: actual 0, expected 1 +42552: actual 0, expected 1 +42553: actual 0, expected 1 +42554: actual 0, expected 1 +42555: actual 0, expected 1 +42556: actual 0, expected 1 +42557: actual 0, expected 1 +42558: actual 0, expected 1 +42559: actual 0, expected 1 +7419: actual 0, expected 1 +7420: actual 0, expected 1 +7421: actual 0, expected 1 +7422: actual 0, expected 1 +7423: actual 0, expected 1 +65050: actual 0, expected 1 +65051: actual 0, expected 1 +65052: actual 0, expected 1 +65053: actual 0, expected 1 +65054: actual 0, expected 1 +65055: actual 0, expected 1 +66928: actual 0, expected 1 +66929: actual 0, expected 1 +66930: actual 0, expected 1 +66931: actual 0, expected 1 +66932: actual 0, expected 1 +66933: actual 0, expected 1 +66934: actual 0, expected 1 +66935: actual 0, expected 1 +66936: actual 0, expected 1 +66937: actual 0, expected 1 +66938: actual 0, expected 1 +66939: actual 0, expected 1 +66940: actual 0, expected 1 +66941: actual 0, expected 1 +66942: actual 0, expected 1 +66943: actual 0, expected 1 +66944: actual 0, expected 1 +66945: actual 0, expected 1 +66946: actual 0, expected 1 +66947: actual 0, expected 1 +66948: actual 0, expected 1 +66949: actual 0, expected 1 +66950: actual 0, expected 1 +66951: actual 0, expected 1 +66952: actual 0, expected 1 +66953: actual 0, expected 1 +66954: actual 0, expected 1 +66955: actual 0, expected 1 +66956: actual 0, expected 1 +66957: actual 0, expected 1 +66958: actual 0, expected 1 +66959: actual 0, expected 1 +66960: actual 0, expected 1 +66961: actual 0, expected 1 +66962: actual 0, expected 1 +66963: actual 0, expected 1 +66964: actual 0, expected 1 +66965: actual 0, expected 1 +66966: actual 0, expected 1 +66967: actual 0, expected 1 +66968: actual 0, expected 1 +66969: actual 0, expected 1 +66970: actual 0, expected 1 +66971: actual 0, expected 1 +66972: actual 0, expected 1 +66973: actual 0, expected 1 +66974: actual 0, expected 1 +66975: actual 0, expected 1 +66976: actual 0, expected 1 +66977: actual 0, expected 1 +66978: actual 0, expected 1 +66979: actual 0, expected 1 +66980: actual 0, expected 1 +66981: actual 0, expected 1 +66982: actual 0, expected 1 +66983: actual 0, expected 1 +66984: actual 0, expected 1 +66985: actual 0, expected 1 +66986: actual 0, expected 1 +66987: actual 0, expected 1 +66988: actual 0, expected 1 +66989: actual 0, expected 1 +66990: actual 0, expected 1 +66991: actual 0, expected 1 +66992: actual 0, expected 1 +66993: actual 0, expected 1 +66994: actual 0, expected 1 +66995: actual 0, expected 1 +66996: actual 0, expected 1 +66997: actual 0, expected 1 +66998: actual 0, expected 1 +66999: actual 0, expected 1 +67000: actual 0, expected 1 +67001: actual 0, expected 1 +67002: actual 0, expected 1 +67003: actual 0, expected 1 +67004: actual 0, expected 1 +67005: actual 0, expected 1 +67006: actual 0, expected 1 +67007: actual 0, expected 1 +123642: actual 0, expected 1 +123643: actual 0, expected 1 +123644: actual 0, expected 1 +123645: actual 0, expected 1 +123646: actual 0, expected 1 +71923: actual 0, expected 1 +71924: actual 0, expected 1 +71925: actual 0, expected 1 +71926: actual 0, expected 1 +71927: actual 0, expected 1 +71928: actual 0, expected 1 +71929: actual 0, expected 1 +71930: actual 0, expected 1 +71931: actual 0, expected 1 +71932: actual 0, expected 1 +71933: actual 0, expected 1 +71934: actual 0, expected 1 +69290: actual 0, expected 1 +69294: actual 0, expected 1 +69295: actual 0, expected 1 +69298: actual 0, expected 1 +69299: actual 0, expected 1 +69300: actual 0, expected 1 +69301: actual 0, expected 1 +69302: actual 0, expected 1 +69303: actual 0, expected 1 +69304: actual 0, expected 1 +69305: actual 0, expected 1 +69306: actual 0, expected 1 +69307: actual 0, expected 1 +69308: actual 0, expected 1 +69309: actual 0, expected 1 +69310: actual 0, expected 1 +69311: actual 0, expected 1 +19904: actual 2, expected 1 +19905: actual 2, expected 1 +19906: actual 2, expected 1 +19907: actual 2, expected 1 +19908: actual 2, expected 1 +19909: actual 2, expected 1 +19910: actual 2, expected 1 +19911: actual 2, expected 1 +19912: actual 2, expected 1 +19913: actual 2, expected 1 +19914: actual 2, expected 1 +19915: actual 2, expected 1 +19916: actual 2, expected 1 +19917: actual 2, expected 1 +19918: actual 2, expected 1 +19919: actual 2, expected 1 +19920: actual 2, expected 1 +19921: actual 2, expected 1 +19922: actual 2, expected 1 +19923: actual 2, expected 1 +19924: actual 2, expected 1 +19925: actual 2, expected 1 +19926: actual 2, expected 1 +19927: actual 2, expected 1 +19928: actual 2, expected 1 +19929: actual 2, expected 1 +19930: actual 2, expected 1 +19931: actual 2, expected 1 +19932: actual 2, expected 1 +19933: actual 2, expected 1 +19934: actual 2, expected 1 +19935: actual 2, expected 1 +19936: actual 2, expected 1 +19937: actual 2, expected 1 +19938: actual 2, expected 1 +19939: actual 2, expected 1 +19940: actual 2, expected 1 +19941: actual 2, expected 1 +19942: actual 2, expected 1 +19943: actual 2, expected 1 +19944: actual 2, expected 1 +19945: actual 2, expected 1 +19946: actual 2, expected 1 +19947: actual 2, expected 1 +19948: actual 2, expected 1 +19949: actual 2, expected 1 +19950: actual 2, expected 1 +19951: actual 2, expected 1 +19952: actual 2, expected 1 +19953: actual 2, expected 1 +19954: actual 2, expected 1 +19955: actual 2, expected 1 +19956: actual 2, expected 1 +19957: actual 2, expected 1 +19958: actual 2, expected 1 +19959: actual 2, expected 1 +19960: actual 2, expected 1 +19961: actual 2, expected 1 +19962: actual 2, expected 1 +19963: actual 2, expected 1 +19964: actual 2, expected 1 +19965: actual 2, expected 1 +19966: actual 2, expected 1 +19967: actual 2, expected 1 +42183: actual 0, expected 1 +42184: actual 0, expected 1 +42185: actual 0, expected 1 +42186: actual 0, expected 1 +42187: actual 0, expected 1 +42188: actual 0, expected 1 +42189: actual 0, expected 1 +42190: actual 0, expected 1 +42191: actual 0, expected 1 +42125: actual 0, expected 1 +42126: actual 0, expected 1 +42127: actual 0, expected 1 +72264: actual 0, expected 1 +72265: actual 0, expected 1 +72266: actual 0, expected 1 +72267: actual 0, expected 1 +72268: actual 0, expected 1 +72269: actual 0, expected 1 +72270: actual 0, expected 1 +72271: actual 0, expected 1 +118574: actual 0, expected 1 +118575: actual 0, expected 1 +118599: actual 0, expected 1 +118600: actual 0, expected 1 +118601: actual 0, expected 1 +118602: actual 0, expected 1 +118603: actual 0, expected 1 +118604: actual 0, expected 1 +118605: actual 0, expected 1 +118606: actual 0, expected 1 +118607: actual 0, expected 1 +118608: actual 0, expected 1 +118609: actual 0, expected 1 +118610: actual 0, expected 1 +118611: actual 0, expected 1 +118612: actual 0, expected 1 +118613: actual 0, expected 1 +118614: actual 0, expected 1 +118615: actual 0, expected 1 +118616: actual 0, expected 1 +118617: actual 0, expected 1 +118618: actual 0, expected 1 +118619: actual 0, expected 1 +118620: actual 0, expected 1 +118621: actual 0, expected 1 +118622: actual 0, expected 1 +118623: actual 0, expected 1 +118624: actual 0, expected 1 +118625: actual 0, expected 1 +118626: actual 0, expected 1 +118627: actual 0, expected 1 +118628: actual 0, expected 1 +118629: actual 0, expected 1 +118630: actual 0, expected 1 +118631: actual 0, expected 1 +118632: actual 0, expected 1 +118633: actual 0, expected 1 +118634: actual 0, expected 1 +118635: actual 0, expected 1 +118636: actual 0, expected 1 +118637: actual 0, expected 1 +118638: actual 0, expected 1 +118639: actual 0, expected 1 +118640: actual 0, expected 1 +118641: actual 0, expected 1 +118642: actual 0, expected 1 +118643: actual 0, expected 1 +118644: actual 0, expected 1 +118645: actual 0, expected 1 +118646: actual 0, expected 1 +118647: actual 0, expected 1 +118648: actual 0, expected 1 +118649: actual 0, expected 1 +118650: actual 0, expected 1 +118651: actual 0, expected 1 +118652: actual 0, expected 1 +118653: actual 0, expected 1 +118654: actual 0, expected 1 +118655: actual 0, expected 1 +118656: actual 0, expected 1 +118657: actual 0, expected 1 +118658: actual 0, expected 1 +118659: actual 0, expected 1 +118660: actual 0, expected 1 +118661: actual 0, expected 1 +118662: actual 0, expected 1 +118663: actual 0, expected 1 +118664: actual 0, expected 1 +118665: actual 0, expected 1 +118666: actual 0, expected 1 +118667: actual 0, expected 1 +118668: actual 0, expected 1 +118669: actual 0, expected 1 +118670: actual 0, expected 1 +118671: actual 0, expected 1 +118672: actual 0, expected 1 +118673: actual 0, expected 1 +118674: actual 0, expected 1 +118675: actual 0, expected 1 +118676: actual 0, expected 1 +118677: actual 0, expected 1 +118678: actual 0, expected 1 +118679: actual 0, expected 1 +118680: actual 0, expected 1 +118681: actual 0, expected 1 +118682: actual 0, expected 1 +118683: actual 0, expected 1 +118684: actual 0, expected 1 +118685: actual 0, expected 1 +118686: actual 0, expected 1 +118687: actual 0, expected 1 +118688: actual 0, expected 1 +118689: actual 0, expected 1 +118690: actual 0, expected 1 +118691: actual 0, expected 1 +118692: actual 0, expected 1 +118693: actual 0, expected 1 +118694: actual 0, expected 1 +118695: actual 0, expected 1 +118696: actual 0, expected 1 +118697: actual 0, expected 1 +118698: actual 0, expected 1 +118699: actual 0, expected 1 +118700: actual 0, expected 1 +118701: actual 0, expected 1 +118702: actual 0, expected 1 +118703: actual 0, expected 1 +118704: actual 0, expected 1 +118705: actual 0, expected 1 +118706: actual 0, expected 1 +118707: actual 0, expected 1 +118708: actual 0, expected 1 +118709: actual 0, expected 1 +118710: actual 0, expected 1 +118711: actual 0, expected 1 +118712: actual 0, expected 1 +118713: actual 0, expected 1 +118714: actual 0, expected 1 +118715: actual 0, expected 1 +118716: actual 0, expected 1 +118717: actual 0, expected 1 +118718: actual 0, expected 1 +118719: actual 0, expected 1 +118720: actual 0, expected 1 +118721: actual 0, expected 1 +118722: actual 0, expected 1 +118723: actual 0, expected 1 +118724: actual 0, expected 1 +118725: actual 0, expected 1 +118726: actual 0, expected 1 +118727: actual 0, expected 1 +118728: actual 0, expected 1 +118729: actual 0, expected 1 +118730: actual 0, expected 1 +118731: actual 0, expected 1 +118732: actual 0, expected 1 +118733: actual 0, expected 1 +118734: actual 0, expected 1 +118735: actual 0, expected 1 diff --git a/widths-gnome-terminal b/widths-gnome-terminal new file mode 100644 index 0000000..313d690 --- /dev/null +++ b/widths-gnome-terminal @@ -0,0 +1,82 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +55216: actual 0, expected 1 +55217: actual 0, expected 1 +55218: actual 0, expected 1 +55219: actual 0, expected 1 +55220: actual 0, expected 1 +55221: actual 0, expected 1 +55222: actual 0, expected 1 +55223: actual 0, expected 1 +55224: actual 0, expected 1 +55225: actual 0, expected 1 +55226: actual 0, expected 1 +55227: actual 0, expected 1 +55228: actual 0, expected 1 +55229: actual 0, expected 1 +55230: actual 0, expected 1 +55231: actual 0, expected 1 +55232: actual 0, expected 1 +55233: actual 0, expected 1 +55234: actual 0, expected 1 +55235: actual 0, expected 1 +55236: actual 0, expected 1 +55237: actual 0, expected 1 +55238: actual 0, expected 1 +55239: actual 0, expected 1 +55240: actual 0, expected 1 +55241: actual 0, expected 1 +55242: actual 0, expected 1 +55243: actual 0, expected 1 +55244: actual 0, expected 1 +55245: actual 0, expected 1 +55246: actual 0, expected 1 +55247: actual 0, expected 1 +55248: actual 0, expected 1 +55249: actual 0, expected 1 +55250: actual 0, expected 1 +55251: actual 0, expected 1 +55252: actual 0, expected 1 +55253: actual 0, expected 1 +55254: actual 0, expected 1 +55255: actual 0, expected 1 +55256: actual 0, expected 1 +55257: actual 0, expected 1 +55258: actual 0, expected 1 +55259: actual 0, expected 1 +55260: actual 0, expected 1 +55261: actual 0, expected 1 +55262: actual 0, expected 1 +55263: actual 0, expected 1 +55264: actual 0, expected 1 +55265: actual 0, expected 1 +55266: actual 0, expected 1 +55267: actual 0, expected 1 +55268: actual 0, expected 1 +55269: actual 0, expected 1 +55270: actual 0, expected 1 +55271: actual 0, expected 1 +55272: actual 0, expected 1 +55273: actual 0, expected 1 +55274: actual 0, expected 1 +55275: actual 0, expected 1 +55276: actual 0, expected 1 +55277: actual 0, expected 1 +55278: actual 0, expected 1 +55279: actual 0, expected 1 +55280: actual 0, expected 1 +55281: actual 0, expected 1 +55282: actual 0, expected 1 +55283: actual 0, expected 1 +55284: actual 0, expected 1 +55285: actual 0, expected 1 +55286: actual 0, expected 1 +55287: actual 0, expected 1 +55288: actual 0, expected 1 +55289: actual 0, expected 1 +55290: actual 0, expected 1 +55291: actual 0, expected 1 +55292: actual 0, expected 1 +55293: actual 0, expected 1 +55294: actual 0, expected 1 +55295: actual 0, expected 1 diff --git a/widths-hyper b/widths-hyper new file mode 100644 index 0000000..a905935 --- /dev/null +++ b/widths-hyper @@ -0,0 +1,2896 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +125252: actual 1, expected 0 +125253: actual 1, expected 0 +125254: actual 1, expected 0 +125255: actual 1, expected 0 +125256: actual 1, expected 0 +125257: actual 1, expected 0 +125258: actual 1, expected 0 +71453: actual 1, expected 0 +71454: actual 1, expected 0 +71455: actual 1, expected 0 +71458: actual 1, expected 0 +71459: actual 1, expected 0 +71460: actual 1, expected 0 +71461: actual 1, expected 0 +71463: actual 1, expected 0 +71464: actual 1, expected 0 +71465: actual 1, expected 0 +71466: actual 1, expected 0 +71467: actual 1, expected 0 +64286: actual 1, expected 0 +119362: actual 1, expected 0 +119363: actual 1, expected 0 +119364: actual 1, expected 0 +1536: actual 1, expected 0 +1537: actual 1, expected 0 +1538: actual 1, expected 0 +1539: actual 1, expected 0 +1540: actual 1, expected 0 +1541: actual 1, expected 0 +1552: actual 1, expected 0 +1553: actual 1, expected 0 +1554: actual 1, expected 0 +1555: actual 1, expected 0 +1556: actual 1, expected 0 +1557: actual 1, expected 0 +1558: actual 1, expected 0 +1559: actual 1, expected 0 +1560: actual 1, expected 0 +1561: actual 1, expected 0 +1562: actual 1, expected 0 +1564: actual 1, expected 0 +1611: actual 1, expected 0 +1612: actual 1, expected 0 +1613: actual 1, expected 0 +1614: actual 1, expected 0 +1615: actual 1, expected 0 +1616: actual 1, expected 0 +1617: actual 1, expected 0 +1618: actual 1, expected 0 +1619: actual 1, expected 0 +1620: actual 1, expected 0 +1621: actual 1, expected 0 +1622: actual 1, expected 0 +1623: actual 1, expected 0 +1624: actual 1, expected 0 +1625: actual 1, expected 0 +1626: actual 1, expected 0 +1627: actual 1, expected 0 +1628: actual 1, expected 0 +1629: actual 1, expected 0 +1630: actual 1, expected 0 +1631: actual 1, expected 0 +1648: actual 1, expected 0 +1750: actual 1, expected 0 +1751: actual 1, expected 0 +1752: actual 1, expected 0 +1753: actual 1, expected 0 +1754: actual 1, expected 0 +1755: actual 1, expected 0 +1756: actual 1, expected 0 +1757: actual 1, expected 0 +1759: actual 1, expected 0 +1760: actual 1, expected 0 +1761: actual 1, expected 0 +1762: actual 1, expected 0 +1763: actual 1, expected 0 +1764: actual 1, expected 0 +1767: actual 1, expected 0 +1768: actual 1, expected 0 +1770: actual 1, expected 0 +1771: actual 1, expected 0 +1772: actual 1, expected 0 +1773: actual 1, expected 0 +2250: actual 1, expected 0 +2251: actual 1, expected 0 +2252: actual 1, expected 0 +2253: actual 1, expected 0 +2254: actual 1, expected 0 +2255: actual 1, expected 0 +2256: actual 1, expected 0 +2257: actual 1, expected 0 +2258: actual 1, expected 0 +2259: actual 1, expected 0 +2260: actual 1, expected 0 +2261: actual 1, expected 0 +2262: actual 1, expected 0 +2263: actual 1, expected 0 +2264: actual 1, expected 0 +2265: actual 1, expected 0 +2266: actual 1, expected 0 +2267: actual 1, expected 0 +2268: actual 1, expected 0 +2269: actual 1, expected 0 +2270: actual 1, expected 0 +2271: actual 1, expected 0 +2272: actual 1, expected 0 +2273: actual 1, expected 0 +2274: actual 1, expected 0 +2275: actual 1, expected 0 +2276: actual 1, expected 0 +2277: actual 1, expected 0 +2278: actual 1, expected 0 +2279: actual 1, expected 0 +2280: actual 1, expected 0 +2281: actual 1, expected 0 +2282: actual 1, expected 0 +2283: actual 1, expected 0 +2284: actual 1, expected 0 +2285: actual 1, expected 0 +2286: actual 1, expected 0 +2287: actual 1, expected 0 +2288: actual 1, expected 0 +2289: actual 1, expected 0 +2290: actual 1, expected 0 +2291: actual 1, expected 0 +2292: actual 1, expected 0 +2293: actual 1, expected 0 +2294: actual 1, expected 0 +2295: actual 1, expected 0 +2296: actual 1, expected 0 +2297: actual 1, expected 0 +2298: actual 1, expected 0 +2299: actual 1, expected 0 +2300: actual 1, expected 0 +2301: actual 1, expected 0 +2302: actual 1, expected 0 +2303: actual 1, expected 0 +2192: actual 1, expected 0 +2193: actual 1, expected 0 +2200: actual 1, expected 0 +2201: actual 1, expected 0 +2202: actual 1, expected 0 +2203: actual 1, expected 0 +2204: actual 1, expected 0 +2205: actual 1, expected 0 +2206: actual 1, expected 0 +2207: actual 1, expected 0 +6912: actual 1, expected 0 +6913: actual 1, expected 0 +6914: actual 1, expected 0 +6915: actual 1, expected 0 +6964: actual 1, expected 0 +6966: actual 1, expected 0 +6967: actual 1, expected 0 +6968: actual 1, expected 0 +6969: actual 1, expected 0 +6970: actual 1, expected 0 +6972: actual 1, expected 0 +6978: actual 1, expected 0 +7019: actual 1, expected 0 +7020: actual 1, expected 0 +7021: actual 1, expected 0 +7022: actual 1, expected 0 +7023: actual 1, expected 0 +7024: actual 1, expected 0 +7025: actual 1, expected 0 +7026: actual 1, expected 0 +7027: actual 1, expected 0 +42736: actual 1, expected 0 +42737: actual 1, expected 0 +92912: actual 1, expected 0 +92913: actual 1, expected 0 +92914: actual 1, expected 0 +92915: actual 1, expected 0 +92916: actual 1, expected 0 +7142: actual 1, expected 0 +7144: actual 1, expected 0 +7145: actual 1, expected 0 +7149: actual 1, expected 0 +7151: actual 1, expected 0 +7152: actual 1, expected 0 +7153: actual 1, expected 0 +2433: actual 1, expected 0 +2492: actual 1, expected 0 +2497: actual 1, expected 0 +2498: actual 1, expected 0 +2499: actual 1, expected 0 +2500: actual 1, expected 0 +2509: actual 1, expected 0 +2530: actual 1, expected 0 +2531: actual 1, expected 0 +2558: actual 1, expected 0 +72752: actual 1, expected 0 +72753: actual 1, expected 0 +72754: actual 1, expected 0 +72755: actual 1, expected 0 +72756: actual 1, expected 0 +72757: actual 1, expected 0 +72758: actual 1, expected 0 +72760: actual 1, expected 0 +72761: actual 1, expected 0 +72762: actual 1, expected 0 +72763: actual 1, expected 0 +72764: actual 1, expected 0 +72765: actual 1, expected 0 +72767: actual 1, expected 0 +12731: actual 1, expected 2 +12732: actual 1, expected 2 +12733: actual 1, expected 2 +12734: actual 1, expected 2 +12735: actual 1, expected 2 +69633: actual 1, expected 0 +69688: actual 1, expected 0 +69689: actual 1, expected 0 +69690: actual 1, expected 0 +69691: actual 1, expected 0 +69692: actual 1, expected 0 +69693: actual 1, expected 0 +69694: actual 1, expected 0 +69695: actual 1, expected 0 +69696: actual 1, expected 0 +69697: actual 1, expected 0 +69698: actual 1, expected 0 +69699: actual 1, expected 0 +69700: actual 1, expected 0 +69701: actual 1, expected 0 +69702: actual 1, expected 0 +69744: actual 1, expected 0 +69747: actual 1, expected 0 +69748: actual 1, expected 0 +69759: actual 1, expected 0 +6679: actual 1, expected 0 +6680: actual 1, expected 0 +6683: actual 1, expected 0 +5970: actual 1, expected 0 +5971: actual 1, expected 0 +69888: actual 1, expected 0 +69889: actual 1, expected 0 +69890: actual 1, expected 0 +69927: actual 1, expected 0 +69928: actual 1, expected 0 +69929: actual 1, expected 0 +69930: actual 1, expected 0 +69931: actual 1, expected 0 +69933: actual 1, expected 0 +69934: actual 1, expected 0 +69935: actual 1, expected 0 +69936: actual 1, expected 0 +69937: actual 1, expected 0 +69938: actual 1, expected 0 +69939: actual 1, expected 0 +69940: actual 1, expected 0 +43561: actual 1, expected 0 +43562: actual 1, expected 0 +43563: actual 1, expected 0 +43564: actual 1, expected 0 +43565: actual 1, expected 0 +43566: actual 1, expected 0 +43569: actual 1, expected 0 +43570: actual 1, expected 0 +43573: actual 1, expected 0 +43574: actual 1, expected 0 +43587: actual 1, expected 0 +43596: actual 1, expected 0 +12330: actual 1, expected 0 +12331: actual 1, expected 0 +12332: actual 1, expected 0 +12333: actual 1, expected 0 +768: actual 1, expected 0 +769: actual 1, expected 0 +770: actual 1, expected 0 +771: actual 1, expected 0 +772: actual 1, expected 0 +773: actual 1, expected 0 +774: actual 1, expected 0 +775: actual 1, expected 0 +776: actual 1, expected 0 +777: actual 1, expected 0 +778: actual 1, expected 0 +779: actual 1, expected 0 +780: actual 1, expected 0 +781: actual 1, expected 0 +782: actual 1, expected 0 +783: actual 1, expected 0 +784: actual 1, expected 0 +785: actual 1, expected 0 +786: actual 1, expected 0 +787: actual 1, expected 0 +788: actual 1, expected 0 +789: actual 1, expected 0 +790: actual 1, expected 0 +791: actual 1, expected 0 +792: actual 1, expected 0 +793: actual 1, expected 0 +794: actual 1, expected 0 +795: actual 1, expected 0 +796: actual 1, expected 0 +797: actual 1, expected 0 +798: actual 1, expected 0 +799: actual 1, expected 0 +800: actual 1, expected 0 +801: actual 1, expected 0 +802: actual 1, expected 0 +803: actual 1, expected 0 +804: actual 1, expected 0 +805: actual 1, expected 0 +806: actual 1, expected 0 +807: actual 1, expected 0 +808: actual 1, expected 0 +809: actual 1, expected 0 +810: actual 1, expected 0 +811: actual 1, expected 0 +812: actual 1, expected 0 +813: actual 1, expected 0 +814: actual 1, expected 0 +815: actual 1, expected 0 +816: actual 1, expected 0 +817: actual 1, expected 0 +818: actual 1, expected 0 +819: actual 1, expected 0 +820: actual 1, expected 0 +821: actual 1, expected 0 +822: actual 1, expected 0 +823: actual 1, expected 0 +824: actual 1, expected 0 +825: actual 1, expected 0 +826: actual 1, expected 0 +827: actual 1, expected 0 +828: actual 1, expected 0 +829: actual 1, expected 0 +830: actual 1, expected 0 +831: actual 1, expected 0 +832: actual 1, expected 0 +833: actual 1, expected 0 +834: actual 1, expected 0 +835: actual 1, expected 0 +836: actual 1, expected 0 +837: actual 1, expected 0 +838: actual 1, expected 0 +839: actual 1, expected 0 +840: actual 1, expected 0 +841: actual 1, expected 0 +842: actual 1, expected 0 +843: actual 1, expected 0 +844: actual 1, expected 0 +845: actual 1, expected 0 +846: actual 1, expected 0 +847: actual 1, expected 0 +848: actual 1, expected 0 +849: actual 1, expected 0 +850: actual 1, expected 0 +851: actual 1, expected 0 +852: actual 1, expected 0 +853: actual 1, expected 0 +854: actual 1, expected 0 +855: actual 1, expected 0 +856: actual 1, expected 0 +857: actual 1, expected 0 +858: actual 1, expected 0 +859: actual 1, expected 0 +860: actual 1, expected 0 +861: actual 1, expected 0 +862: actual 1, expected 0 +863: actual 1, expected 0 +864: actual 1, expected 0 +865: actual 1, expected 0 +866: actual 1, expected 0 +867: actual 1, expected 0 +868: actual 1, expected 0 +869: actual 1, expected 0 +870: actual 1, expected 0 +871: actual 1, expected 0 +872: actual 1, expected 0 +873: actual 1, expected 0 +874: actual 1, expected 0 +875: actual 1, expected 0 +876: actual 1, expected 0 +877: actual 1, expected 0 +878: actual 1, expected 0 +879: actual 1, expected 0 +6832: actual 1, expected 0 +6833: actual 1, expected 0 +6834: actual 1, expected 0 +6835: actual 1, expected 0 +6836: actual 1, expected 0 +6837: actual 1, expected 0 +6838: actual 1, expected 0 +6839: actual 1, expected 0 +6840: actual 1, expected 0 +6841: actual 1, expected 0 +6842: actual 1, expected 0 +6843: actual 1, expected 0 +6844: actual 1, expected 0 +6845: actual 1, expected 0 +6846: actual 1, expected 0 +6847: actual 1, expected 0 +6848: actual 1, expected 0 +6849: actual 1, expected 0 +6850: actual 1, expected 0 +6851: actual 1, expected 0 +6852: actual 1, expected 0 +6853: actual 1, expected 0 +6854: actual 1, expected 0 +6855: actual 1, expected 0 +6856: actual 1, expected 0 +6857: actual 1, expected 0 +6858: actual 1, expected 0 +6859: actual 1, expected 0 +6860: actual 1, expected 0 +6861: actual 1, expected 0 +6862: actual 1, expected 0 +8400: actual 1, expected 0 +8401: actual 1, expected 0 +8402: actual 1, expected 0 +8403: actual 1, expected 0 +8404: actual 1, expected 0 +8405: actual 1, expected 0 +8406: actual 1, expected 0 +8407: actual 1, expected 0 +8408: actual 1, expected 0 +8409: actual 1, expected 0 +8410: actual 1, expected 0 +8411: actual 1, expected 0 +8412: actual 1, expected 0 +8413: actual 1, expected 0 +8414: actual 1, expected 0 +8415: actual 1, expected 0 +8416: actual 1, expected 0 +8417: actual 1, expected 0 +8418: actual 1, expected 0 +8419: actual 1, expected 0 +8420: actual 1, expected 0 +8421: actual 1, expected 0 +8422: actual 1, expected 0 +8423: actual 1, expected 0 +8424: actual 1, expected 0 +8425: actual 1, expected 0 +8426: actual 1, expected 0 +8427: actual 1, expected 0 +8428: actual 1, expected 0 +8429: actual 1, expected 0 +8430: actual 1, expected 0 +8431: actual 1, expected 0 +8432: actual 1, expected 0 +7616: actual 1, expected 0 +7617: actual 1, expected 0 +7618: actual 1, expected 0 +7619: actual 1, expected 0 +7620: actual 1, expected 0 +7621: actual 1, expected 0 +7622: actual 1, expected 0 +7623: actual 1, expected 0 +7624: actual 1, expected 0 +7625: actual 1, expected 0 +7626: actual 1, expected 0 +7627: actual 1, expected 0 +7628: actual 1, expected 0 +7629: actual 1, expected 0 +7630: actual 1, expected 0 +7631: actual 1, expected 0 +7632: actual 1, expected 0 +7633: actual 1, expected 0 +7634: actual 1, expected 0 +7635: actual 1, expected 0 +7636: actual 1, expected 0 +7637: actual 1, expected 0 +7638: actual 1, expected 0 +7639: actual 1, expected 0 +7640: actual 1, expected 0 +7641: actual 1, expected 0 +7642: actual 1, expected 0 +7643: actual 1, expected 0 +7644: actual 1, expected 0 +7645: actual 1, expected 0 +7646: actual 1, expected 0 +7647: actual 1, expected 0 +7648: actual 1, expected 0 +7649: actual 1, expected 0 +7650: actual 1, expected 0 +7651: actual 1, expected 0 +7652: actual 1, expected 0 +7653: actual 1, expected 0 +7654: actual 1, expected 0 +7655: actual 1, expected 0 +7656: actual 1, expected 0 +7657: actual 1, expected 0 +7658: actual 1, expected 0 +7659: actual 1, expected 0 +7660: actual 1, expected 0 +7661: actual 1, expected 0 +7662: actual 1, expected 0 +7663: actual 1, expected 0 +7664: actual 1, expected 0 +7665: actual 1, expected 0 +7666: actual 1, expected 0 +7667: actual 1, expected 0 +7668: actual 1, expected 0 +7669: actual 1, expected 0 +7670: actual 1, expected 0 +7671: actual 1, expected 0 +7672: actual 1, expected 0 +7673: actual 1, expected 0 +7674: actual 1, expected 0 +7675: actual 1, expected 0 +7676: actual 1, expected 0 +7677: actual 1, expected 0 +7678: actual 1, expected 0 +7679: actual 1, expected 0 +65056: actual 1, expected 0 +65057: actual 1, expected 0 +65058: actual 1, expected 0 +65059: actual 1, expected 0 +65060: actual 1, expected 0 +65061: actual 1, expected 0 +65062: actual 1, expected 0 +65063: actual 1, expected 0 +65064: actual 1, expected 0 +65065: actual 1, expected 0 +65066: actual 1, expected 0 +65067: actual 1, expected 0 +65068: actual 1, expected 0 +65069: actual 1, expected 0 +65070: actual 1, expected 0 +65071: actual 1, expected 0 +11503: actual 1, expected 0 +11504: actual 1, expected 0 +11505: actual 1, expected 0 +66272: actual 1, expected 0 +1155: actual 1, expected 0 +1156: actual 1, expected 0 +1157: actual 1, expected 0 +1158: actual 1, expected 0 +1159: actual 1, expected 0 +1160: actual 1, expected 0 +1161: actual 1, expected 0 +11744: actual 1, expected 0 +11745: actual 1, expected 0 +11746: actual 1, expected 0 +11747: actual 1, expected 0 +11748: actual 1, expected 0 +11749: actual 1, expected 0 +11750: actual 1, expected 0 +11751: actual 1, expected 0 +11752: actual 1, expected 0 +11753: actual 1, expected 0 +11754: actual 1, expected 0 +11755: actual 1, expected 0 +11756: actual 1, expected 0 +11757: actual 1, expected 0 +11758: actual 1, expected 0 +11759: actual 1, expected 0 +11760: actual 1, expected 0 +11761: actual 1, expected 0 +11762: actual 1, expected 0 +11763: actual 1, expected 0 +11764: actual 1, expected 0 +11765: actual 1, expected 0 +11766: actual 1, expected 0 +11767: actual 1, expected 0 +11768: actual 1, expected 0 +11769: actual 1, expected 0 +11770: actual 1, expected 0 +11771: actual 1, expected 0 +11772: actual 1, expected 0 +11773: actual 1, expected 0 +11774: actual 1, expected 0 +11775: actual 1, expected 0 +42607: actual 1, expected 0 +42608: actual 1, expected 0 +42609: actual 1, expected 0 +42610: actual 1, expected 0 +42612: actual 1, expected 0 +42613: actual 1, expected 0 +42614: actual 1, expected 0 +42615: actual 1, expected 0 +42616: actual 1, expected 0 +42617: actual 1, expected 0 +42618: actual 1, expected 0 +42619: actual 1, expected 0 +42620: actual 1, expected 0 +42621: actual 1, expected 0 +42654: actual 1, expected 0 +42655: actual 1, expected 0 +2304: actual 1, expected 0 +2305: actual 1, expected 0 +2306: actual 1, expected 0 +2362: actual 1, expected 0 +2364: actual 1, expected 0 +2369: actual 1, expected 0 +2370: actual 1, expected 0 +2371: actual 1, expected 0 +2372: actual 1, expected 0 +2373: actual 1, expected 0 +2374: actual 1, expected 0 +2375: actual 1, expected 0 +2376: actual 1, expected 0 +2381: actual 1, expected 0 +2385: actual 1, expected 0 +2386: actual 1, expected 0 +2387: actual 1, expected 0 +2388: actual 1, expected 0 +2389: actual 1, expected 0 +2390: actual 1, expected 0 +2391: actual 1, expected 0 +2402: actual 1, expected 0 +2403: actual 1, expected 0 +43232: actual 1, expected 0 +43233: actual 1, expected 0 +43234: actual 1, expected 0 +43235: actual 1, expected 0 +43236: actual 1, expected 0 +43237: actual 1, expected 0 +43238: actual 1, expected 0 +43239: actual 1, expected 0 +43240: actual 1, expected 0 +43241: actual 1, expected 0 +43242: actual 1, expected 0 +43243: actual 1, expected 0 +43244: actual 1, expected 0 +43245: actual 1, expected 0 +43246: actual 1, expected 0 +43247: actual 1, expected 0 +43248: actual 1, expected 0 +43249: actual 1, expected 0 +43263: actual 1, expected 0 +71995: actual 1, expected 0 +71996: actual 1, expected 0 +71998: actual 1, expected 0 +72003: actual 1, expected 0 +71727: actual 1, expected 0 +71728: actual 1, expected 0 +71729: actual 1, expected 0 +71730: actual 1, expected 0 +71731: actual 1, expected 0 +71732: actual 1, expected 0 +71733: actual 1, expected 0 +71734: actual 1, expected 0 +71735: actual 1, expected 0 +71737: actual 1, expected 0 +71738: actual 1, expected 0 +113821: actual 1, expected 0 +113822: actual 1, expected 0 +78896: actual 1, expected 0 +78897: actual 1, expected 0 +78898: actual 1, expected 0 +78899: actual 1, expected 0 +78900: actual 1, expected 0 +78901: actual 1, expected 0 +78902: actual 1, expected 0 +78903: actual 1, expected 0 +78904: actual 1, expected 0 +4957: actual 1, expected 0 +4958: actual 1, expected 0 +4959: actual 1, expected 0 +8203: actual 1, expected 0 +8204: actual 1, expected 0 +8205: actual 1, expected 0 +8206: actual 1, expected 0 +8207: actual 1, expected 0 +8234: actual 1, expected 0 +8235: actual 1, expected 0 +8236: actual 1, expected 0 +8237: actual 1, expected 0 +8238: actual 1, expected 0 +8288: actual 1, expected 0 +8289: actual 1, expected 0 +8290: actual 1, expected 0 +8291: actual 1, expected 0 +8292: actual 1, expected 0 +8294: actual 1, expected 0 +8295: actual 1, expected 0 +8296: actual 1, expected 0 +8297: actual 1, expected 0 +8298: actual 1, expected 0 +8299: actual 1, expected 0 +8300: actual 1, expected 0 +8301: actual 1, expected 0 +8302: actual 1, expected 0 +8303: actual 1, expected 0 +129008: actual 1, expected 2 +122880: actual 1, expected 0 +122881: actual 1, expected 0 +122882: actual 1, expected 0 +122883: actual 1, expected 0 +122884: actual 1, expected 0 +122885: actual 1, expected 0 +122886: actual 1, expected 0 +122888: actual 1, expected 0 +122889: actual 1, expected 0 +122890: actual 1, expected 0 +122891: actual 1, expected 0 +122892: actual 1, expected 0 +122893: actual 1, expected 0 +122894: actual 1, expected 0 +122895: actual 1, expected 0 +122896: actual 1, expected 0 +122897: actual 1, expected 0 +122898: actual 1, expected 0 +122899: actual 1, expected 0 +122900: actual 1, expected 0 +122901: actual 1, expected 0 +122902: actual 1, expected 0 +122903: actual 1, expected 0 +122904: actual 1, expected 0 +122907: actual 1, expected 0 +122908: actual 1, expected 0 +122909: actual 1, expected 0 +122910: actual 1, expected 0 +122911: actual 1, expected 0 +122912: actual 1, expected 0 +122913: actual 1, expected 0 +122915: actual 1, expected 0 +122916: actual 1, expected 0 +122918: actual 1, expected 0 +122919: actual 1, expected 0 +122920: actual 1, expected 0 +122921: actual 1, expected 0 +122922: actual 1, expected 0 +70400: actual 1, expected 0 +70401: actual 1, expected 0 +70459: actual 1, expected 0 +70460: actual 1, expected 0 +70464: actual 1, expected 0 +70502: actual 1, expected 0 +70503: actual 1, expected 0 +70504: actual 1, expected 0 +70505: actual 1, expected 0 +70506: actual 1, expected 0 +70507: actual 1, expected 0 +70508: actual 1, expected 0 +70512: actual 1, expected 0 +70513: actual 1, expected 0 +70514: actual 1, expected 0 +70515: actual 1, expected 0 +70516: actual 1, expected 0 +2689: actual 1, expected 0 +2690: actual 1, expected 0 +2748: actual 1, expected 0 +2753: actual 1, expected 0 +2754: actual 1, expected 0 +2755: actual 1, expected 0 +2756: actual 1, expected 0 +2757: actual 1, expected 0 +2759: actual 1, expected 0 +2760: actual 1, expected 0 +2765: actual 1, expected 0 +2786: actual 1, expected 0 +2787: actual 1, expected 0 +2810: actual 1, expected 0 +2811: actual 1, expected 0 +2812: actual 1, expected 0 +2813: actual 1, expected 0 +2814: actual 1, expected 0 +2815: actual 1, expected 0 +73104: actual 1, expected 0 +73105: actual 1, expected 0 +73109: actual 1, expected 0 +73111: actual 1, expected 0 +2561: actual 1, expected 0 +2562: actual 1, expected 0 +2620: actual 1, expected 0 +2625: actual 1, expected 0 +2626: actual 1, expected 0 +2631: actual 1, expected 0 +2632: actual 1, expected 0 +2635: actual 1, expected 0 +2636: actual 1, expected 0 +2637: actual 1, expected 0 +2641: actual 1, expected 0 +2672: actual 1, expected 0 +2673: actual 1, expected 0 +2677: actual 1, expected 0 +4448: actual 1, expected 0 +4449: actual 1, expected 0 +4450: actual 1, expected 0 +4451: actual 1, expected 0 +4452: actual 1, expected 0 +4453: actual 1, expected 0 +4454: actual 1, expected 0 +4455: actual 1, expected 0 +4456: actual 1, expected 0 +4457: actual 1, expected 0 +4458: actual 1, expected 0 +4459: actual 1, expected 0 +4460: actual 1, expected 0 +4461: actual 1, expected 0 +4462: actual 1, expected 0 +4463: actual 1, expected 0 +4464: actual 1, expected 0 +4465: actual 1, expected 0 +4466: actual 1, expected 0 +4467: actual 1, expected 0 +4468: actual 1, expected 0 +4469: actual 1, expected 0 +4470: actual 1, expected 0 +4471: actual 1, expected 0 +4472: actual 1, expected 0 +4473: actual 1, expected 0 +4474: actual 1, expected 0 +4475: actual 1, expected 0 +4476: actual 1, expected 0 +4477: actual 1, expected 0 +4478: actual 1, expected 0 +4479: actual 1, expected 0 +4480: actual 1, expected 0 +4481: actual 1, expected 0 +4482: actual 1, expected 0 +4483: actual 1, expected 0 +4484: actual 1, expected 0 +4485: actual 1, expected 0 +4486: actual 1, expected 0 +4487: actual 1, expected 0 +4488: actual 1, expected 0 +4489: actual 1, expected 0 +4490: actual 1, expected 0 +4491: actual 1, expected 0 +4492: actual 1, expected 0 +4493: actual 1, expected 0 +4494: actual 1, expected 0 +4495: actual 1, expected 0 +4496: actual 1, expected 0 +4497: actual 1, expected 0 +4498: actual 1, expected 0 +4499: actual 1, expected 0 +4500: actual 1, expected 0 +4501: actual 1, expected 0 +4502: actual 1, expected 0 +4503: actual 1, expected 0 +4504: actual 1, expected 0 +4505: actual 1, expected 0 +4506: actual 1, expected 0 +4507: actual 1, expected 0 +4508: actual 1, expected 0 +4509: actual 1, expected 0 +4510: actual 1, expected 0 +4511: actual 1, expected 0 +4512: actual 1, expected 0 +4513: actual 1, expected 0 +4514: actual 1, expected 0 +4515: actual 1, expected 0 +4516: actual 1, expected 0 +4517: actual 1, expected 0 +4518: actual 1, expected 0 +4519: actual 1, expected 0 +4520: actual 1, expected 0 +4521: actual 1, expected 0 +4522: actual 1, expected 0 +4523: actual 1, expected 0 +4524: actual 1, expected 0 +4525: actual 1, expected 0 +4526: actual 1, expected 0 +4527: actual 1, expected 0 +4528: actual 1, expected 0 +4529: actual 1, expected 0 +4530: actual 1, expected 0 +4531: actual 1, expected 0 +4532: actual 1, expected 0 +4533: actual 1, expected 0 +4534: actual 1, expected 0 +4535: actual 1, expected 0 +4536: actual 1, expected 0 +4537: actual 1, expected 0 +4538: actual 1, expected 0 +4539: actual 1, expected 0 +4540: actual 1, expected 0 +4541: actual 1, expected 0 +4542: actual 1, expected 0 +4543: actual 1, expected 0 +4544: actual 1, expected 0 +4545: actual 1, expected 0 +4546: actual 1, expected 0 +4547: actual 1, expected 0 +4548: actual 1, expected 0 +4549: actual 1, expected 0 +4550: actual 1, expected 0 +4551: actual 1, expected 0 +4552: actual 1, expected 0 +4553: actual 1, expected 0 +4554: actual 1, expected 0 +4555: actual 1, expected 0 +4556: actual 1, expected 0 +4557: actual 1, expected 0 +4558: actual 1, expected 0 +4559: actual 1, expected 0 +4560: actual 1, expected 0 +4561: actual 1, expected 0 +4562: actual 1, expected 0 +4563: actual 1, expected 0 +4564: actual 1, expected 0 +4565: actual 1, expected 0 +4566: actual 1, expected 0 +4567: actual 1, expected 0 +4568: actual 1, expected 0 +4569: actual 1, expected 0 +4570: actual 1, expected 0 +4571: actual 1, expected 0 +4572: actual 1, expected 0 +4573: actual 1, expected 0 +4574: actual 1, expected 0 +4575: actual 1, expected 0 +4576: actual 1, expected 0 +4577: actual 1, expected 0 +4578: actual 1, expected 0 +4579: actual 1, expected 0 +4580: actual 1, expected 0 +4581: actual 1, expected 0 +4582: actual 1, expected 0 +4583: actual 1, expected 0 +4584: actual 1, expected 0 +4585: actual 1, expected 0 +4586: actual 1, expected 0 +4587: actual 1, expected 0 +4588: actual 1, expected 0 +4589: actual 1, expected 0 +4590: actual 1, expected 0 +4591: actual 1, expected 0 +4592: actual 1, expected 0 +4593: actual 1, expected 0 +4594: actual 1, expected 0 +4595: actual 1, expected 0 +4596: actual 1, expected 0 +4597: actual 1, expected 0 +4598: actual 1, expected 0 +4599: actual 1, expected 0 +4600: actual 1, expected 0 +4601: actual 1, expected 0 +4602: actual 1, expected 0 +4603: actual 1, expected 0 +4604: actual 1, expected 0 +4605: actual 1, expected 0 +4606: actual 1, expected 0 +4607: actual 1, expected 0 +68900: actual 1, expected 0 +68901: actual 1, expected 0 +68902: actual 1, expected 0 +68903: actual 1, expected 0 +5938: actual 1, expected 0 +5939: actual 1, expected 0 +1425: actual 1, expected 0 +1426: actual 1, expected 0 +1427: actual 1, expected 0 +1428: actual 1, expected 0 +1429: actual 1, expected 0 +1430: actual 1, expected 0 +1431: actual 1, expected 0 +1432: actual 1, expected 0 +1433: actual 1, expected 0 +1434: actual 1, expected 0 +1435: actual 1, expected 0 +1436: actual 1, expected 0 +1437: actual 1, expected 0 +1438: actual 1, expected 0 +1439: actual 1, expected 0 +1440: actual 1, expected 0 +1441: actual 1, expected 0 +1442: actual 1, expected 0 +1443: actual 1, expected 0 +1444: actual 1, expected 0 +1445: actual 1, expected 0 +1446: actual 1, expected 0 +1447: actual 1, expected 0 +1448: actual 1, expected 0 +1449: actual 1, expected 0 +1450: actual 1, expected 0 +1451: actual 1, expected 0 +1452: actual 1, expected 0 +1453: actual 1, expected 0 +1454: actual 1, expected 0 +1455: actual 1, expected 0 +1456: actual 1, expected 0 +1457: actual 1, expected 0 +1458: actual 1, expected 0 +1459: actual 1, expected 0 +1460: actual 1, expected 0 +1461: actual 1, expected 0 +1462: actual 1, expected 0 +1463: actual 1, expected 0 +1464: actual 1, expected 0 +1465: actual 1, expected 0 +1466: actual 1, expected 0 +1467: actual 1, expected 0 +1468: actual 1, expected 0 +1469: actual 1, expected 0 +1471: actual 1, expected 0 +1473: actual 1, expected 0 +1474: actual 1, expected 0 +1476: actual 1, expected 0 +1477: actual 1, expected 0 +1479: actual 1, expected 0 +12441: actual 1, expected 0 +12442: actual 1, expected 0 +94180: actual 1, expected 0 +94192: actual 1, expected 2 +94193: actual 1, expected 2 +43392: actual 1, expected 0 +43393: actual 1, expected 0 +43394: actual 1, expected 0 +43443: actual 1, expected 0 +43446: actual 1, expected 0 +43447: actual 1, expected 0 +43448: actual 1, expected 0 +43449: actual 1, expected 0 +43452: actual 1, expected 0 +43453: actual 1, expected 0 +69760: actual 1, expected 0 +69761: actual 1, expected 0 +69811: actual 1, expected 0 +69812: actual 1, expected 0 +69813: actual 1, expected 0 +69814: actual 1, expected 0 +69817: actual 1, expected 0 +69818: actual 1, expected 0 +69821: actual 1, expected 0 +69826: actual 1, expected 0 +69837: actual 1, expected 0 +110879: actual 1, expected 2 +110880: actual 1, expected 2 +110881: actual 1, expected 2 +110882: actual 1, expected 2 +110576: actual 1, expected 2 +110577: actual 1, expected 2 +110578: actual 1, expected 2 +110579: actual 1, expected 2 +110581: actual 1, expected 2 +110582: actual 1, expected 2 +110583: actual 1, expected 2 +110584: actual 1, expected 2 +110585: actual 1, expected 2 +110586: actual 1, expected 2 +110587: actual 1, expected 2 +110589: actual 1, expected 2 +110590: actual 1, expected 2 +3201: actual 1, expected 0 +3260: actual 1, expected 0 +3263: actual 1, expected 0 +3270: actual 1, expected 0 +3276: actual 1, expected 0 +3277: actual 1, expected 0 +3298: actual 1, expected 0 +3299: actual 1, expected 0 +43302: actual 1, expected 0 +43303: actual 1, expected 0 +43304: actual 1, expected 0 +43305: actual 1, expected 0 +43306: actual 1, expected 0 +43307: actual 1, expected 0 +43308: actual 1, expected 0 +43309: actual 1, expected 0 +68097: actual 1, expected 0 +68098: actual 1, expected 0 +68099: actual 1, expected 0 +68101: actual 1, expected 0 +68102: actual 1, expected 0 +68108: actual 1, expected 0 +68109: actual 1, expected 0 +68110: actual 1, expected 0 +68111: actual 1, expected 0 +68152: actual 1, expected 0 +68153: actual 1, expected 0 +68154: actual 1, expected 0 +68159: actual 1, expected 0 +101120: actual 1, expected 2 +101121: actual 1, expected 2 +101122: actual 1, expected 2 +101123: actual 1, expected 2 +101124: actual 1, expected 2 +101125: actual 1, expected 2 +101126: actual 1, expected 2 +101127: actual 1, expected 2 +101128: actual 1, expected 2 +101129: actual 1, expected 2 +101130: actual 1, expected 2 +101131: actual 1, expected 2 +101132: actual 1, expected 2 +101133: actual 1, expected 2 +101134: actual 1, expected 2 +101135: actual 1, expected 2 +101136: actual 1, expected 2 +101137: actual 1, expected 2 +101138: actual 1, expected 2 +101139: actual 1, expected 2 +101140: actual 1, expected 2 +101141: actual 1, expected 2 +101142: actual 1, expected 2 +101143: actual 1, expected 2 +101144: actual 1, expected 2 +101145: actual 1, expected 2 +101146: actual 1, expected 2 +101147: actual 1, expected 2 +101148: actual 1, expected 2 +101149: actual 1, expected 2 +101150: actual 1, expected 2 +101151: actual 1, expected 2 +101152: actual 1, expected 2 +101153: actual 1, expected 2 +101154: actual 1, expected 2 +101155: actual 1, expected 2 +101156: actual 1, expected 2 +101157: actual 1, expected 2 +101158: actual 1, expected 2 +101159: actual 1, expected 2 +101160: actual 1, expected 2 +101161: actual 1, expected 2 +101162: actual 1, expected 2 +101163: actual 1, expected 2 +101164: actual 1, expected 2 +101165: actual 1, expected 2 +101166: actual 1, expected 2 +101167: actual 1, expected 2 +101168: actual 1, expected 2 +101169: actual 1, expected 2 +101170: actual 1, expected 2 +101171: actual 1, expected 2 +101172: actual 1, expected 2 +101173: actual 1, expected 2 +101174: actual 1, expected 2 +101175: actual 1, expected 2 +101176: actual 1, expected 2 +101177: actual 1, expected 2 +101178: actual 1, expected 2 +101179: actual 1, expected 2 +101180: actual 1, expected 2 +101181: actual 1, expected 2 +101182: actual 1, expected 2 +101183: actual 1, expected 2 +101184: actual 1, expected 2 +101185: actual 1, expected 2 +101186: actual 1, expected 2 +101187: actual 1, expected 2 +101188: actual 1, expected 2 +101189: actual 1, expected 2 +101190: actual 1, expected 2 +101191: actual 1, expected 2 +101192: actual 1, expected 2 +101193: actual 1, expected 2 +101194: actual 1, expected 2 +101195: actual 1, expected 2 +101196: actual 1, expected 2 +101197: actual 1, expected 2 +101198: actual 1, expected 2 +101199: actual 1, expected 2 +101200: actual 1, expected 2 +101201: actual 1, expected 2 +101202: actual 1, expected 2 +101203: actual 1, expected 2 +101204: actual 1, expected 2 +101205: actual 1, expected 2 +101206: actual 1, expected 2 +101207: actual 1, expected 2 +101208: actual 1, expected 2 +101209: actual 1, expected 2 +101210: actual 1, expected 2 +101211: actual 1, expected 2 +101212: actual 1, expected 2 +101213: actual 1, expected 2 +101214: actual 1, expected 2 +101215: actual 1, expected 2 +101216: actual 1, expected 2 +101217: actual 1, expected 2 +101218: actual 1, expected 2 +101219: actual 1, expected 2 +101220: actual 1, expected 2 +101221: actual 1, expected 2 +101222: actual 1, expected 2 +101223: actual 1, expected 2 +101224: actual 1, expected 2 +101225: actual 1, expected 2 +101226: actual 1, expected 2 +101227: actual 1, expected 2 +101228: actual 1, expected 2 +101229: actual 1, expected 2 +101230: actual 1, expected 2 +101231: actual 1, expected 2 +101232: actual 1, expected 2 +101233: actual 1, expected 2 +101234: actual 1, expected 2 +101235: actual 1, expected 2 +101236: actual 1, expected 2 +101237: actual 1, expected 2 +101238: actual 1, expected 2 +101239: actual 1, expected 2 +101240: actual 1, expected 2 +101241: actual 1, expected 2 +101242: actual 1, expected 2 +101243: actual 1, expected 2 +101244: actual 1, expected 2 +101245: actual 1, expected 2 +101246: actual 1, expected 2 +101247: actual 1, expected 2 +101248: actual 1, expected 2 +101249: actual 1, expected 2 +101250: actual 1, expected 2 +101251: actual 1, expected 2 +101252: actual 1, expected 2 +101253: actual 1, expected 2 +101254: actual 1, expected 2 +101255: actual 1, expected 2 +101256: actual 1, expected 2 +101257: actual 1, expected 2 +101258: actual 1, expected 2 +101259: actual 1, expected 2 +101260: actual 1, expected 2 +101261: actual 1, expected 2 +101262: actual 1, expected 2 +101263: actual 1, expected 2 +101264: actual 1, expected 2 +101265: actual 1, expected 2 +101266: actual 1, expected 2 +101267: actual 1, expected 2 +101268: actual 1, expected 2 +101269: actual 1, expected 2 +101270: actual 1, expected 2 +101271: actual 1, expected 2 +101272: actual 1, expected 2 +101273: actual 1, expected 2 +101274: actual 1, expected 2 +101275: actual 1, expected 2 +101276: actual 1, expected 2 +101277: actual 1, expected 2 +101278: actual 1, expected 2 +101279: actual 1, expected 2 +101280: actual 1, expected 2 +101281: actual 1, expected 2 +101282: actual 1, expected 2 +101283: actual 1, expected 2 +101284: actual 1, expected 2 +101285: actual 1, expected 2 +101286: actual 1, expected 2 +101287: actual 1, expected 2 +101288: actual 1, expected 2 +101289: actual 1, expected 2 +101290: actual 1, expected 2 +101291: actual 1, expected 2 +101292: actual 1, expected 2 +101293: actual 1, expected 2 +101294: actual 1, expected 2 +101295: actual 1, expected 2 +101296: actual 1, expected 2 +101297: actual 1, expected 2 +101298: actual 1, expected 2 +101299: actual 1, expected 2 +101300: actual 1, expected 2 +101301: actual 1, expected 2 +101302: actual 1, expected 2 +101303: actual 1, expected 2 +101304: actual 1, expected 2 +101305: actual 1, expected 2 +101306: actual 1, expected 2 +101307: actual 1, expected 2 +101308: actual 1, expected 2 +101309: actual 1, expected 2 +101310: actual 1, expected 2 +101311: actual 1, expected 2 +101312: actual 1, expected 2 +101313: actual 1, expected 2 +101314: actual 1, expected 2 +101315: actual 1, expected 2 +101316: actual 1, expected 2 +101317: actual 1, expected 2 +101318: actual 1, expected 2 +101319: actual 1, expected 2 +101320: actual 1, expected 2 +101321: actual 1, expected 2 +101322: actual 1, expected 2 +101323: actual 1, expected 2 +101324: actual 1, expected 2 +101325: actual 1, expected 2 +101326: actual 1, expected 2 +101327: actual 1, expected 2 +101328: actual 1, expected 2 +101329: actual 1, expected 2 +101330: actual 1, expected 2 +101331: actual 1, expected 2 +101332: actual 1, expected 2 +101333: actual 1, expected 2 +101334: actual 1, expected 2 +101335: actual 1, expected 2 +101336: actual 1, expected 2 +101337: actual 1, expected 2 +101338: actual 1, expected 2 +101339: actual 1, expected 2 +101340: actual 1, expected 2 +101341: actual 1, expected 2 +101342: actual 1, expected 2 +101343: actual 1, expected 2 +101344: actual 1, expected 2 +101345: actual 1, expected 2 +101346: actual 1, expected 2 +101347: actual 1, expected 2 +101348: actual 1, expected 2 +101349: actual 1, expected 2 +101350: actual 1, expected 2 +101351: actual 1, expected 2 +101352: actual 1, expected 2 +101353: actual 1, expected 2 +101354: actual 1, expected 2 +101355: actual 1, expected 2 +101356: actual 1, expected 2 +101357: actual 1, expected 2 +101358: actual 1, expected 2 +101359: actual 1, expected 2 +101360: actual 1, expected 2 +101361: actual 1, expected 2 +101362: actual 1, expected 2 +101363: actual 1, expected 2 +101364: actual 1, expected 2 +101365: actual 1, expected 2 +101366: actual 1, expected 2 +101367: actual 1, expected 2 +101368: actual 1, expected 2 +101369: actual 1, expected 2 +101370: actual 1, expected 2 +101371: actual 1, expected 2 +101372: actual 1, expected 2 +101373: actual 1, expected 2 +101374: actual 1, expected 2 +101375: actual 1, expected 2 +101376: actual 1, expected 2 +101377: actual 1, expected 2 +101378: actual 1, expected 2 +101379: actual 1, expected 2 +101380: actual 1, expected 2 +101381: actual 1, expected 2 +101382: actual 1, expected 2 +101383: actual 1, expected 2 +101384: actual 1, expected 2 +101385: actual 1, expected 2 +101386: actual 1, expected 2 +101387: actual 1, expected 2 +101388: actual 1, expected 2 +101389: actual 1, expected 2 +101390: actual 1, expected 2 +101391: actual 1, expected 2 +101392: actual 1, expected 2 +101393: actual 1, expected 2 +101394: actual 1, expected 2 +101395: actual 1, expected 2 +101396: actual 1, expected 2 +101397: actual 1, expected 2 +101398: actual 1, expected 2 +101399: actual 1, expected 2 +101400: actual 1, expected 2 +101401: actual 1, expected 2 +101402: actual 1, expected 2 +101403: actual 1, expected 2 +101404: actual 1, expected 2 +101405: actual 1, expected 2 +101406: actual 1, expected 2 +101407: actual 1, expected 2 +101408: actual 1, expected 2 +101409: actual 1, expected 2 +101410: actual 1, expected 2 +101411: actual 1, expected 2 +101412: actual 1, expected 2 +101413: actual 1, expected 2 +101414: actual 1, expected 2 +101415: actual 1, expected 2 +101416: actual 1, expected 2 +101417: actual 1, expected 2 +101418: actual 1, expected 2 +101419: actual 1, expected 2 +101420: actual 1, expected 2 +101421: actual 1, expected 2 +101422: actual 1, expected 2 +101423: actual 1, expected 2 +101424: actual 1, expected 2 +101425: actual 1, expected 2 +101426: actual 1, expected 2 +101427: actual 1, expected 2 +101428: actual 1, expected 2 +101429: actual 1, expected 2 +101430: actual 1, expected 2 +101431: actual 1, expected 2 +101432: actual 1, expected 2 +101433: actual 1, expected 2 +101434: actual 1, expected 2 +101435: actual 1, expected 2 +101436: actual 1, expected 2 +101437: actual 1, expected 2 +101438: actual 1, expected 2 +101439: actual 1, expected 2 +101440: actual 1, expected 2 +101441: actual 1, expected 2 +101442: actual 1, expected 2 +101443: actual 1, expected 2 +101444: actual 1, expected 2 +101445: actual 1, expected 2 +101446: actual 1, expected 2 +101447: actual 1, expected 2 +101448: actual 1, expected 2 +101449: actual 1, expected 2 +101450: actual 1, expected 2 +101451: actual 1, expected 2 +101452: actual 1, expected 2 +101453: actual 1, expected 2 +101454: actual 1, expected 2 +101455: actual 1, expected 2 +101456: actual 1, expected 2 +101457: actual 1, expected 2 +101458: actual 1, expected 2 +101459: actual 1, expected 2 +101460: actual 1, expected 2 +101461: actual 1, expected 2 +101462: actual 1, expected 2 +101463: actual 1, expected 2 +101464: actual 1, expected 2 +101465: actual 1, expected 2 +101466: actual 1, expected 2 +101467: actual 1, expected 2 +101468: actual 1, expected 2 +101469: actual 1, expected 2 +101470: actual 1, expected 2 +101471: actual 1, expected 2 +101472: actual 1, expected 2 +101473: actual 1, expected 2 +101474: actual 1, expected 2 +101475: actual 1, expected 2 +101476: actual 1, expected 2 +101477: actual 1, expected 2 +101478: actual 1, expected 2 +101479: actual 1, expected 2 +101480: actual 1, expected 2 +101481: actual 1, expected 2 +101482: actual 1, expected 2 +101483: actual 1, expected 2 +101484: actual 1, expected 2 +101485: actual 1, expected 2 +101486: actual 1, expected 2 +101487: actual 1, expected 2 +101488: actual 1, expected 2 +101489: actual 1, expected 2 +101490: actual 1, expected 2 +101491: actual 1, expected 2 +101492: actual 1, expected 2 +101493: actual 1, expected 2 +101494: actual 1, expected 2 +101495: actual 1, expected 2 +101496: actual 1, expected 2 +101497: actual 1, expected 2 +101498: actual 1, expected 2 +101499: actual 1, expected 2 +101500: actual 1, expected 2 +101501: actual 1, expected 2 +101502: actual 1, expected 2 +101503: actual 1, expected 2 +101504: actual 1, expected 2 +101505: actual 1, expected 2 +101506: actual 1, expected 2 +101507: actual 1, expected 2 +101508: actual 1, expected 2 +101509: actual 1, expected 2 +101510: actual 1, expected 2 +101511: actual 1, expected 2 +101512: actual 1, expected 2 +101513: actual 1, expected 2 +101514: actual 1, expected 2 +101515: actual 1, expected 2 +101516: actual 1, expected 2 +101517: actual 1, expected 2 +101518: actual 1, expected 2 +101519: actual 1, expected 2 +101520: actual 1, expected 2 +101521: actual 1, expected 2 +101522: actual 1, expected 2 +101523: actual 1, expected 2 +101524: actual 1, expected 2 +101525: actual 1, expected 2 +101526: actual 1, expected 2 +101527: actual 1, expected 2 +101528: actual 1, expected 2 +101529: actual 1, expected 2 +101530: actual 1, expected 2 +101531: actual 1, expected 2 +101532: actual 1, expected 2 +101533: actual 1, expected 2 +101534: actual 1, expected 2 +101535: actual 1, expected 2 +101536: actual 1, expected 2 +101537: actual 1, expected 2 +101538: actual 1, expected 2 +101539: actual 1, expected 2 +101540: actual 1, expected 2 +101541: actual 1, expected 2 +101542: actual 1, expected 2 +101543: actual 1, expected 2 +101544: actual 1, expected 2 +101545: actual 1, expected 2 +101546: actual 1, expected 2 +101547: actual 1, expected 2 +101548: actual 1, expected 2 +101549: actual 1, expected 2 +101550: actual 1, expected 2 +101551: actual 1, expected 2 +101552: actual 1, expected 2 +101553: actual 1, expected 2 +101554: actual 1, expected 2 +101555: actual 1, expected 2 +101556: actual 1, expected 2 +101557: actual 1, expected 2 +101558: actual 1, expected 2 +101559: actual 1, expected 2 +101560: actual 1, expected 2 +101561: actual 1, expected 2 +101562: actual 1, expected 2 +101563: actual 1, expected 2 +101564: actual 1, expected 2 +101565: actual 1, expected 2 +101566: actual 1, expected 2 +101567: actual 1, expected 2 +101568: actual 1, expected 2 +101569: actual 1, expected 2 +101570: actual 1, expected 2 +101571: actual 1, expected 2 +101572: actual 1, expected 2 +101573: actual 1, expected 2 +101574: actual 1, expected 2 +101575: actual 1, expected 2 +101576: actual 1, expected 2 +101577: actual 1, expected 2 +101578: actual 1, expected 2 +101579: actual 1, expected 2 +101580: actual 1, expected 2 +101581: actual 1, expected 2 +101582: actual 1, expected 2 +101583: actual 1, expected 2 +101584: actual 1, expected 2 +101585: actual 1, expected 2 +101586: actual 1, expected 2 +101587: actual 1, expected 2 +101588: actual 1, expected 2 +101589: actual 1, expected 2 +6068: actual 1, expected 0 +6069: actual 1, expected 0 +6071: actual 1, expected 0 +6072: actual 1, expected 0 +6073: actual 1, expected 0 +6074: actual 1, expected 0 +6075: actual 1, expected 0 +6076: actual 1, expected 0 +6077: actual 1, expected 0 +6086: actual 1, expected 0 +6089: actual 1, expected 0 +6090: actual 1, expected 0 +6091: actual 1, expected 0 +6092: actual 1, expected 0 +6093: actual 1, expected 0 +6094: actual 1, expected 0 +6095: actual 1, expected 0 +6096: actual 1, expected 0 +6097: actual 1, expected 0 +6098: actual 1, expected 0 +6099: actual 1, expected 0 +6109: actual 1, expected 0 +70191: actual 1, expected 0 +70192: actual 1, expected 0 +70193: actual 1, expected 0 +70196: actual 1, expected 0 +70198: actual 1, expected 0 +70199: actual 1, expected 0 +70206: actual 1, expected 0 +70367: actual 1, expected 0 +70371: actual 1, expected 0 +70372: actual 1, expected 0 +70373: actual 1, expected 0 +70374: actual 1, expected 0 +70375: actual 1, expected 0 +70376: actual 1, expected 0 +70377: actual 1, expected 0 +70378: actual 1, expected 0 +3761: actual 1, expected 0 +3764: actual 1, expected 0 +3765: actual 1, expected 0 +3766: actual 1, expected 0 +3767: actual 1, expected 0 +3768: actual 1, expected 0 +3769: actual 1, expected 0 +3770: actual 1, expected 0 +3771: actual 1, expected 0 +3772: actual 1, expected 0 +3784: actual 1, expected 0 +3785: actual 1, expected 0 +3786: actual 1, expected 0 +3787: actual 1, expected 0 +3788: actual 1, expected 0 +3789: actual 1, expected 0 +7212: actual 1, expected 0 +7213: actual 1, expected 0 +7214: actual 1, expected 0 +7215: actual 1, expected 0 +7216: actual 1, expected 0 +7217: actual 1, expected 0 +7218: actual 1, expected 0 +7219: actual 1, expected 0 +7222: actual 1, expected 0 +7223: actual 1, expected 0 +6432: actual 1, expected 0 +6433: actual 1, expected 0 +6434: actual 1, expected 0 +6439: actual 1, expected 0 +6440: actual 1, expected 0 +6450: actual 1, expected 0 +6457: actual 1, expected 0 +6458: actual 1, expected 0 +6459: actual 1, expected 0 +70003: actual 1, expected 0 +73459: actual 1, expected 0 +73460: actual 1, expected 0 +3328: actual 1, expected 0 +3329: actual 1, expected 0 +3387: actual 1, expected 0 +3388: actual 1, expected 0 +3393: actual 1, expected 0 +3394: actual 1, expected 0 +3395: actual 1, expected 0 +3396: actual 1, expected 0 +3405: actual 1, expected 0 +3426: actual 1, expected 0 +3427: actual 1, expected 0 +2137: actual 1, expected 0 +2138: actual 1, expected 0 +2139: actual 1, expected 0 +68325: actual 1, expected 0 +68326: actual 1, expected 0 +72850: actual 1, expected 0 +72851: actual 1, expected 0 +72852: actual 1, expected 0 +72853: actual 1, expected 0 +72854: actual 1, expected 0 +72855: actual 1, expected 0 +72856: actual 1, expected 0 +72857: actual 1, expected 0 +72858: actual 1, expected 0 +72859: actual 1, expected 0 +72860: actual 1, expected 0 +72861: actual 1, expected 0 +72862: actual 1, expected 0 +72863: actual 1, expected 0 +72864: actual 1, expected 0 +72865: actual 1, expected 0 +72866: actual 1, expected 0 +72867: actual 1, expected 0 +72868: actual 1, expected 0 +72869: actual 1, expected 0 +72870: actual 1, expected 0 +72871: actual 1, expected 0 +72874: actual 1, expected 0 +72875: actual 1, expected 0 +72876: actual 1, expected 0 +72877: actual 1, expected 0 +72878: actual 1, expected 0 +72879: actual 1, expected 0 +72880: actual 1, expected 0 +72882: actual 1, expected 0 +72883: actual 1, expected 0 +72885: actual 1, expected 0 +72886: actual 1, expected 0 +73009: actual 1, expected 0 +73010: actual 1, expected 0 +73011: actual 1, expected 0 +73012: actual 1, expected 0 +73013: actual 1, expected 0 +73014: actual 1, expected 0 +73018: actual 1, expected 0 +73020: actual 1, expected 0 +73021: actual 1, expected 0 +73023: actual 1, expected 0 +73024: actual 1, expected 0 +73025: actual 1, expected 0 +73026: actual 1, expected 0 +73027: actual 1, expected 0 +73028: actual 1, expected 0 +73029: actual 1, expected 0 +73031: actual 1, expected 0 +44005: actual 1, expected 0 +44008: actual 1, expected 0 +44013: actual 1, expected 0 +43756: actual 1, expected 0 +43757: actual 1, expected 0 +43766: actual 1, expected 0 +125136: actual 1, expected 0 +125137: actual 1, expected 0 +125138: actual 1, expected 0 +125139: actual 1, expected 0 +125140: actual 1, expected 0 +125141: actual 1, expected 0 +125142: actual 1, expected 0 +94031: actual 1, expected 0 +94095: actual 1, expected 0 +94096: actual 1, expected 0 +94097: actual 1, expected 0 +94098: actual 1, expected 0 +71219: actual 1, expected 0 +71220: actual 1, expected 0 +71221: actual 1, expected 0 +71222: actual 1, expected 0 +71223: actual 1, expected 0 +71224: actual 1, expected 0 +71225: actual 1, expected 0 +71226: actual 1, expected 0 +71229: actual 1, expected 0 +71231: actual 1, expected 0 +71232: actual 1, expected 0 +6155: actual 1, expected 0 +6156: actual 1, expected 0 +6157: actual 1, expected 0 +6158: actual 1, expected 0 +6159: actual 1, expected 0 +6277: actual 1, expected 0 +6278: actual 1, expected 0 +6313: actual 1, expected 0 +119143: actual 1, expected 0 +119144: actual 1, expected 0 +119145: actual 1, expected 0 +119155: actual 1, expected 0 +119156: actual 1, expected 0 +119157: actual 1, expected 0 +119158: actual 1, expected 0 +119159: actual 1, expected 0 +119160: actual 1, expected 0 +119161: actual 1, expected 0 +119162: actual 1, expected 0 +119163: actual 1, expected 0 +119164: actual 1, expected 0 +119165: actual 1, expected 0 +119166: actual 1, expected 0 +119167: actual 1, expected 0 +119168: actual 1, expected 0 +119169: actual 1, expected 0 +119170: actual 1, expected 0 +119173: actual 1, expected 0 +119174: actual 1, expected 0 +119175: actual 1, expected 0 +119176: actual 1, expected 0 +119177: actual 1, expected 0 +119178: actual 1, expected 0 +119179: actual 1, expected 0 +119210: actual 1, expected 0 +119211: actual 1, expected 0 +119212: actual 1, expected 0 +119213: actual 1, expected 0 +4141: actual 1, expected 0 +4142: actual 1, expected 0 +4143: actual 1, expected 0 +4144: actual 1, expected 0 +4146: actual 1, expected 0 +4147: actual 1, expected 0 +4148: actual 1, expected 0 +4149: actual 1, expected 0 +4150: actual 1, expected 0 +4151: actual 1, expected 0 +4153: actual 1, expected 0 +4154: actual 1, expected 0 +4157: actual 1, expected 0 +4158: actual 1, expected 0 +4184: actual 1, expected 0 +4185: actual 1, expected 0 +4190: actual 1, expected 0 +4191: actual 1, expected 0 +4192: actual 1, expected 0 +4209: actual 1, expected 0 +4210: actual 1, expected 0 +4211: actual 1, expected 0 +4212: actual 1, expected 0 +4226: actual 1, expected 0 +4229: actual 1, expected 0 +4230: actual 1, expected 0 +4237: actual 1, expected 0 +4253: actual 1, expected 0 +43644: actual 1, expected 0 +43493: actual 1, expected 0 +72148: actual 1, expected 0 +72149: actual 1, expected 0 +72150: actual 1, expected 0 +72151: actual 1, expected 0 +72154: actual 1, expected 0 +72155: actual 1, expected 0 +72160: actual 1, expected 0 +70712: actual 1, expected 0 +70713: actual 1, expected 0 +70714: actual 1, expected 0 +70715: actual 1, expected 0 +70716: actual 1, expected 0 +70717: actual 1, expected 0 +70718: actual 1, expected 0 +70719: actual 1, expected 0 +70722: actual 1, expected 0 +70723: actual 1, expected 0 +70724: actual 1, expected 0 +70726: actual 1, expected 0 +70750: actual 1, expected 0 +2027: actual 1, expected 0 +2028: actual 1, expected 0 +2029: actual 1, expected 0 +2030: actual 1, expected 0 +2031: actual 1, expected 0 +2032: actual 1, expected 0 +2033: actual 1, expected 0 +2034: actual 1, expected 0 +2035: actual 1, expected 0 +2045: actual 1, expected 0 +123184: actual 1, expected 0 +123185: actual 1, expected 0 +123186: actual 1, expected 0 +123187: actual 1, expected 0 +123188: actual 1, expected 0 +123189: actual 1, expected 0 +123190: actual 1, expected 0 +66422: actual 1, expected 0 +66423: actual 1, expected 0 +66424: actual 1, expected 0 +66425: actual 1, expected 0 +66426: actual 1, expected 0 +69506: actual 1, expected 0 +69507: actual 1, expected 0 +69508: actual 1, expected 0 +69509: actual 1, expected 0 +2817: actual 1, expected 0 +2876: actual 1, expected 0 +2879: actual 1, expected 0 +2881: actual 1, expected 0 +2882: actual 1, expected 0 +2883: actual 1, expected 0 +2884: actual 1, expected 0 +2893: actual 1, expected 0 +2901: actual 1, expected 0 +2902: actual 1, expected 0 +2914: actual 1, expected 0 +2915: actual 1, expected 0 +92976: actual 1, expected 0 +92977: actual 1, expected 0 +92978: actual 1, expected 0 +92979: actual 1, expected 0 +92980: actual 1, expected 0 +92981: actual 1, expected 0 +92982: actual 1, expected 0 +66045: actual 1, expected 0 +43335: actual 1, expected 0 +43336: actual 1, expected 0 +43337: actual 1, expected 0 +43338: actual 1, expected 0 +43339: actual 1, expected 0 +43340: actual 1, expected 0 +43341: actual 1, expected 0 +43342: actual 1, expected 0 +43343: actual 1, expected 0 +43344: actual 1, expected 0 +43345: actual 1, expected 0 +2070: actual 1, expected 0 +2071: actual 1, expected 0 +2072: actual 1, expected 0 +2073: actual 1, expected 0 +2075: actual 1, expected 0 +2076: actual 1, expected 0 +2077: actual 1, expected 0 +2078: actual 1, expected 0 +2079: actual 1, expected 0 +2080: actual 1, expected 0 +2081: actual 1, expected 0 +2082: actual 1, expected 0 +2083: actual 1, expected 0 +2085: actual 1, expected 0 +2086: actual 1, expected 0 +2087: actual 1, expected 0 +2089: actual 1, expected 0 +2090: actual 1, expected 0 +2091: actual 1, expected 0 +2092: actual 1, expected 0 +2093: actual 1, expected 0 +43204: actual 1, expected 0 +43205: actual 1, expected 0 +70016: actual 1, expected 0 +70017: actual 1, expected 0 +70070: actual 1, expected 0 +70071: actual 1, expected 0 +70072: actual 1, expected 0 +70073: actual 1, expected 0 +70074: actual 1, expected 0 +70075: actual 1, expected 0 +70076: actual 1, expected 0 +70077: actual 1, expected 0 +70078: actual 1, expected 0 +70089: actual 1, expected 0 +70090: actual 1, expected 0 +70091: actual 1, expected 0 +70092: actual 1, expected 0 +70095: actual 1, expected 0 +113824: actual 1, expected 0 +113825: actual 1, expected 0 +113826: actual 1, expected 0 +113827: actual 1, expected 0 +71090: actual 1, expected 0 +71091: actual 1, expected 0 +71092: actual 1, expected 0 +71093: actual 1, expected 0 +71100: actual 1, expected 0 +71101: actual 1, expected 0 +71103: actual 1, expected 0 +71104: actual 1, expected 0 +71132: actual 1, expected 0 +71133: actual 1, expected 0 +3457: actual 1, expected 0 +3530: actual 1, expected 0 +3538: actual 1, expected 0 +3539: actual 1, expected 0 +3540: actual 1, expected 0 +3542: actual 1, expected 0 +69446: actual 1, expected 0 +69447: actual 1, expected 0 +69448: actual 1, expected 0 +69449: actual 1, expected 0 +69450: actual 1, expected 0 +69451: actual 1, expected 0 +69452: actual 1, expected 0 +69453: actual 1, expected 0 +69454: actual 1, expected 0 +69455: actual 1, expected 0 +69456: actual 1, expected 0 +72273: actual 1, expected 0 +72274: actual 1, expected 0 +72275: actual 1, expected 0 +72276: actual 1, expected 0 +72277: actual 1, expected 0 +72278: actual 1, expected 0 +72281: actual 1, expected 0 +72282: actual 1, expected 0 +72283: actual 1, expected 0 +72330: actual 1, expected 0 +72331: actual 1, expected 0 +72332: actual 1, expected 0 +72333: actual 1, expected 0 +72334: actual 1, expected 0 +72335: actual 1, expected 0 +72336: actual 1, expected 0 +72337: actual 1, expected 0 +72338: actual 1, expected 0 +72339: actual 1, expected 0 +72340: actual 1, expected 0 +72341: actual 1, expected 0 +72342: actual 1, expected 0 +72344: actual 1, expected 0 +72345: actual 1, expected 0 +65529: actual 1, expected 0 +65530: actual 1, expected 0 +65531: actual 1, expected 0 +7040: actual 1, expected 0 +7041: actual 1, expected 0 +7074: actual 1, expected 0 +7075: actual 1, expected 0 +7076: actual 1, expected 0 +7077: actual 1, expected 0 +7080: actual 1, expected 0 +7081: actual 1, expected 0 +7083: actual 1, expected 0 +7084: actual 1, expected 0 +7085: actual 1, expected 0 +129292: actual 1, expected 2 +129339: actual 2, expected 1 +129350: actual 2, expected 1 +129394: actual 1, expected 2 +129399: actual 1, expected 2 +129400: actual 1, expected 2 +129401: actual 1, expected 2 +129443: actual 1, expected 2 +129444: actual 1, expected 2 +129451: actual 1, expected 2 +129452: actual 1, expected 2 +129453: actual 1, expected 2 +129483: actual 1, expected 2 +129484: actual 1, expected 2 +121344: actual 1, expected 0 +121345: actual 1, expected 0 +121346: actual 1, expected 0 +121347: actual 1, expected 0 +121348: actual 1, expected 0 +121349: actual 1, expected 0 +121350: actual 1, expected 0 +121351: actual 1, expected 0 +121352: actual 1, expected 0 +121353: actual 1, expected 0 +121354: actual 1, expected 0 +121355: actual 1, expected 0 +121356: actual 1, expected 0 +121357: actual 1, expected 0 +121358: actual 1, expected 0 +121359: actual 1, expected 0 +121360: actual 1, expected 0 +121361: actual 1, expected 0 +121362: actual 1, expected 0 +121363: actual 1, expected 0 +121364: actual 1, expected 0 +121365: actual 1, expected 0 +121366: actual 1, expected 0 +121367: actual 1, expected 0 +121368: actual 1, expected 0 +121369: actual 1, expected 0 +121370: actual 1, expected 0 +121371: actual 1, expected 0 +121372: actual 1, expected 0 +121373: actual 1, expected 0 +121374: actual 1, expected 0 +121375: actual 1, expected 0 +121376: actual 1, expected 0 +121377: actual 1, expected 0 +121378: actual 1, expected 0 +121379: actual 1, expected 0 +121380: actual 1, expected 0 +121381: actual 1, expected 0 +121382: actual 1, expected 0 +121383: actual 1, expected 0 +121384: actual 1, expected 0 +121385: actual 1, expected 0 +121386: actual 1, expected 0 +121387: actual 1, expected 0 +121388: actual 1, expected 0 +121389: actual 1, expected 0 +121390: actual 1, expected 0 +121391: actual 1, expected 0 +121392: actual 1, expected 0 +121393: actual 1, expected 0 +121394: actual 1, expected 0 +121395: actual 1, expected 0 +121396: actual 1, expected 0 +121397: actual 1, expected 0 +121398: actual 1, expected 0 +121403: actual 1, expected 0 +121404: actual 1, expected 0 +121405: actual 1, expected 0 +121406: actual 1, expected 0 +121407: actual 1, expected 0 +121408: actual 1, expected 0 +121409: actual 1, expected 0 +121410: actual 1, expected 0 +121411: actual 1, expected 0 +121412: actual 1, expected 0 +121413: actual 1, expected 0 +121414: actual 1, expected 0 +121415: actual 1, expected 0 +121416: actual 1, expected 0 +121417: actual 1, expected 0 +121418: actual 1, expected 0 +121419: actual 1, expected 0 +121420: actual 1, expected 0 +121421: actual 1, expected 0 +121422: actual 1, expected 0 +121423: actual 1, expected 0 +121424: actual 1, expected 0 +121425: actual 1, expected 0 +121426: actual 1, expected 0 +121427: actual 1, expected 0 +121428: actual 1, expected 0 +121429: actual 1, expected 0 +121430: actual 1, expected 0 +121431: actual 1, expected 0 +121432: actual 1, expected 0 +121433: actual 1, expected 0 +121434: actual 1, expected 0 +121435: actual 1, expected 0 +121436: actual 1, expected 0 +121437: actual 1, expected 0 +121438: actual 1, expected 0 +121439: actual 1, expected 0 +121440: actual 1, expected 0 +121441: actual 1, expected 0 +121442: actual 1, expected 0 +121443: actual 1, expected 0 +121444: actual 1, expected 0 +121445: actual 1, expected 0 +121446: actual 1, expected 0 +121447: actual 1, expected 0 +121448: actual 1, expected 0 +121449: actual 1, expected 0 +121450: actual 1, expected 0 +121451: actual 1, expected 0 +121452: actual 1, expected 0 +121461: actual 1, expected 0 +121476: actual 1, expected 0 +121499: actual 1, expected 0 +121500: actual 1, expected 0 +121501: actual 1, expected 0 +121502: actual 1, expected 0 +121503: actual 1, expected 0 +121505: actual 1, expected 0 +121506: actual 1, expected 0 +121507: actual 1, expected 0 +121508: actual 1, expected 0 +121509: actual 1, expected 0 +121510: actual 1, expected 0 +121511: actual 1, expected 0 +121512: actual 1, expected 0 +121513: actual 1, expected 0 +121514: actual 1, expected 0 +121515: actual 1, expected 0 +121516: actual 1, expected 0 +121517: actual 1, expected 0 +121518: actual 1, expected 0 +121519: actual 1, expected 0 +43010: actual 1, expected 0 +43014: actual 1, expected 0 +43019: actual 1, expected 0 +43045: actual 1, expected 0 +43046: actual 1, expected 0 +43052: actual 1, expected 0 +129652: actual 1, expected 2 +129659: actual 1, expected 2 +129660: actual 1, expected 2 +129667: actual 1, expected 2 +129668: actual 1, expected 2 +129669: actual 1, expected 2 +129670: actual 1, expected 2 +129686: actual 1, expected 2 +129687: actual 1, expected 2 +129688: actual 1, expected 2 +129689: actual 1, expected 2 +129690: actual 1, expected 2 +129691: actual 1, expected 2 +129692: actual 1, expected 2 +129693: actual 1, expected 2 +129694: actual 1, expected 2 +129695: actual 1, expected 2 +129696: actual 1, expected 2 +129697: actual 1, expected 2 +129698: actual 1, expected 2 +129699: actual 1, expected 2 +129700: actual 1, expected 2 +129701: actual 1, expected 2 +129702: actual 1, expected 2 +129703: actual 1, expected 2 +129704: actual 1, expected 2 +129705: actual 1, expected 2 +129706: actual 1, expected 2 +129707: actual 1, expected 2 +129708: actual 1, expected 2 +129712: actual 1, expected 2 +129713: actual 1, expected 2 +129714: actual 1, expected 2 +129715: actual 1, expected 2 +129716: actual 1, expected 2 +129717: actual 1, expected 2 +129718: actual 1, expected 2 +129719: actual 1, expected 2 +129720: actual 1, expected 2 +129721: actual 1, expected 2 +129722: actual 1, expected 2 +129728: actual 1, expected 2 +129729: actual 1, expected 2 +129730: actual 1, expected 2 +129731: actual 1, expected 2 +129732: actual 1, expected 2 +129733: actual 1, expected 2 +129744: actual 1, expected 2 +129745: actual 1, expected 2 +129746: actual 1, expected 2 +129747: actual 1, expected 2 +129748: actual 1, expected 2 +129749: actual 1, expected 2 +129750: actual 1, expected 2 +129751: actual 1, expected 2 +129752: actual 1, expected 2 +129753: actual 1, expected 2 +129760: actual 1, expected 2 +129761: actual 1, expected 2 +129762: actual 1, expected 2 +129763: actual 1, expected 2 +129764: actual 1, expected 2 +129765: actual 1, expected 2 +129766: actual 1, expected 2 +129767: actual 1, expected 2 +129776: actual 1, expected 2 +129777: actual 1, expected 2 +129778: actual 1, expected 2 +129779: actual 1, expected 2 +129780: actual 1, expected 2 +129781: actual 1, expected 2 +129782: actual 1, expected 2 +1807: actual 1, expected 0 +1809: actual 1, expected 0 +1840: actual 1, expected 0 +1841: actual 1, expected 0 +1842: actual 1, expected 0 +1843: actual 1, expected 0 +1844: actual 1, expected 0 +1845: actual 1, expected 0 +1846: actual 1, expected 0 +1847: actual 1, expected 0 +1848: actual 1, expected 0 +1849: actual 1, expected 0 +1850: actual 1, expected 0 +1851: actual 1, expected 0 +1852: actual 1, expected 0 +1853: actual 1, expected 0 +1854: actual 1, expected 0 +1855: actual 1, expected 0 +1856: actual 1, expected 0 +1857: actual 1, expected 0 +1858: actual 1, expected 0 +1859: actual 1, expected 0 +1860: actual 1, expected 0 +1861: actual 1, expected 0 +1862: actual 1, expected 0 +1863: actual 1, expected 0 +1864: actual 1, expected 0 +1865: actual 1, expected 0 +1866: actual 1, expected 0 +5906: actual 1, expected 0 +5907: actual 1, expected 0 +5908: actual 1, expected 0 +6002: actual 1, expected 0 +6003: actual 1, expected 0 +917505: actual 1, expected 0 +917536: actual 1, expected 0 +917537: actual 1, expected 0 +917538: actual 1, expected 0 +917539: actual 1, expected 0 +917540: actual 1, expected 0 +917541: actual 1, expected 0 +917542: actual 1, expected 0 +917543: actual 1, expected 0 +917544: actual 1, expected 0 +917545: actual 1, expected 0 +917546: actual 1, expected 0 +917547: actual 1, expected 0 +917548: actual 1, expected 0 +917549: actual 1, expected 0 +917550: actual 1, expected 0 +917551: actual 1, expected 0 +917552: actual 1, expected 0 +917553: actual 1, expected 0 +917554: actual 1, expected 0 +917555: actual 1, expected 0 +917556: actual 1, expected 0 +917557: actual 1, expected 0 +917558: actual 1, expected 0 +917559: actual 1, expected 0 +917560: actual 1, expected 0 +917561: actual 1, expected 0 +917562: actual 1, expected 0 +917563: actual 1, expected 0 +917564: actual 1, expected 0 +917565: actual 1, expected 0 +917566: actual 1, expected 0 +917567: actual 1, expected 0 +917568: actual 1, expected 0 +917569: actual 1, expected 0 +917570: actual 1, expected 0 +917571: actual 1, expected 0 +917572: actual 1, expected 0 +917573: actual 1, expected 0 +917574: actual 1, expected 0 +917575: actual 1, expected 0 +917576: actual 1, expected 0 +917577: actual 1, expected 0 +917578: actual 1, expected 0 +917579: actual 1, expected 0 +917580: actual 1, expected 0 +917581: actual 1, expected 0 +917582: actual 1, expected 0 +917583: actual 1, expected 0 +917584: actual 1, expected 0 +917585: actual 1, expected 0 +917586: actual 1, expected 0 +917587: actual 1, expected 0 +917588: actual 1, expected 0 +917589: actual 1, expected 0 +917590: actual 1, expected 0 +917591: actual 1, expected 0 +917592: actual 1, expected 0 +917593: actual 1, expected 0 +917594: actual 1, expected 0 +917595: actual 1, expected 0 +917596: actual 1, expected 0 +917597: actual 1, expected 0 +917598: actual 1, expected 0 +917599: actual 1, expected 0 +917600: actual 1, expected 0 +917601: actual 1, expected 0 +917602: actual 1, expected 0 +917603: actual 1, expected 0 +917604: actual 1, expected 0 +917605: actual 1, expected 0 +917606: actual 1, expected 0 +917607: actual 1, expected 0 +917608: actual 1, expected 0 +917609: actual 1, expected 0 +917610: actual 1, expected 0 +917611: actual 1, expected 0 +917612: actual 1, expected 0 +917613: actual 1, expected 0 +917614: actual 1, expected 0 +917615: actual 1, expected 0 +917616: actual 1, expected 0 +917617: actual 1, expected 0 +917618: actual 1, expected 0 +917619: actual 1, expected 0 +917620: actual 1, expected 0 +917621: actual 1, expected 0 +917622: actual 1, expected 0 +917623: actual 1, expected 0 +917624: actual 1, expected 0 +917625: actual 1, expected 0 +917626: actual 1, expected 0 +917627: actual 1, expected 0 +917628: actual 1, expected 0 +917629: actual 1, expected 0 +917630: actual 1, expected 0 +917631: actual 1, expected 0 +6742: actual 1, expected 0 +6744: actual 1, expected 0 +6745: actual 1, expected 0 +6746: actual 1, expected 0 +6747: actual 1, expected 0 +6748: actual 1, expected 0 +6749: actual 1, expected 0 +6750: actual 1, expected 0 +6752: actual 1, expected 0 +6754: actual 1, expected 0 +6757: actual 1, expected 0 +6758: actual 1, expected 0 +6759: actual 1, expected 0 +6760: actual 1, expected 0 +6761: actual 1, expected 0 +6762: actual 1, expected 0 +6763: actual 1, expected 0 +6764: actual 1, expected 0 +6771: actual 1, expected 0 +6772: actual 1, expected 0 +6773: actual 1, expected 0 +6774: actual 1, expected 0 +6775: actual 1, expected 0 +6776: actual 1, expected 0 +6777: actual 1, expected 0 +6778: actual 1, expected 0 +6779: actual 1, expected 0 +6780: actual 1, expected 0 +6783: actual 1, expected 0 +43696: actual 1, expected 0 +43698: actual 1, expected 0 +43699: actual 1, expected 0 +43700: actual 1, expected 0 +43703: actual 1, expected 0 +43704: actual 1, expected 0 +43710: actual 1, expected 0 +43711: actual 1, expected 0 +43713: actual 1, expected 0 +71339: actual 1, expected 0 +71341: actual 1, expected 0 +71344: actual 1, expected 0 +71345: actual 1, expected 0 +71346: actual 1, expected 0 +71347: actual 1, expected 0 +71348: actual 1, expected 0 +71349: actual 1, expected 0 +71351: actual 1, expected 0 +2946: actual 1, expected 0 +3008: actual 1, expected 0 +3021: actual 1, expected 0 +101107: actual 1, expected 2 +101108: actual 1, expected 2 +101109: actual 1, expected 2 +101110: actual 1, expected 2 +101111: actual 1, expected 2 +101112: actual 1, expected 2 +101113: actual 1, expected 2 +101114: actual 1, expected 2 +101115: actual 1, expected 2 +101116: actual 1, expected 2 +101117: actual 1, expected 2 +101118: actual 1, expected 2 +101119: actual 1, expected 2 +101632: actual 1, expected 2 +101633: actual 1, expected 2 +101634: actual 1, expected 2 +101635: actual 1, expected 2 +101636: actual 1, expected 2 +101637: actual 1, expected 2 +101638: actual 1, expected 2 +101639: actual 1, expected 2 +101640: actual 1, expected 2 +3072: actual 1, expected 0 +3076: actual 1, expected 0 +3132: actual 1, expected 0 +3134: actual 1, expected 0 +3135: actual 1, expected 0 +3136: actual 1, expected 0 +3142: actual 1, expected 0 +3143: actual 1, expected 0 +3144: actual 1, expected 0 +3146: actual 1, expected 0 +3147: actual 1, expected 0 +3148: actual 1, expected 0 +3149: actual 1, expected 0 +3157: actual 1, expected 0 +3158: actual 1, expected 0 +3170: actual 1, expected 0 +3171: actual 1, expected 0 +1958: actual 1, expected 0 +1959: actual 1, expected 0 +1960: actual 1, expected 0 +1961: actual 1, expected 0 +1962: actual 1, expected 0 +1963: actual 1, expected 0 +1964: actual 1, expected 0 +1965: actual 1, expected 0 +1966: actual 1, expected 0 +1967: actual 1, expected 0 +1968: actual 1, expected 0 +3633: actual 1, expected 0 +3636: actual 1, expected 0 +3637: actual 1, expected 0 +3638: actual 1, expected 0 +3639: actual 1, expected 0 +3640: actual 1, expected 0 +3641: actual 1, expected 0 +3642: actual 1, expected 0 +3655: actual 1, expected 0 +3656: actual 1, expected 0 +3657: actual 1, expected 0 +3658: actual 1, expected 0 +3659: actual 1, expected 0 +3660: actual 1, expected 0 +3661: actual 1, expected 0 +3662: actual 1, expected 0 +3864: actual 1, expected 0 +3865: actual 1, expected 0 +3893: actual 1, expected 0 +3895: actual 1, expected 0 +3897: actual 1, expected 0 +3953: actual 1, expected 0 +3954: actual 1, expected 0 +3955: actual 1, expected 0 +3956: actual 1, expected 0 +3957: actual 1, expected 0 +3958: actual 1, expected 0 +3959: actual 1, expected 0 +3960: actual 1, expected 0 +3961: actual 1, expected 0 +3962: actual 1, expected 0 +3963: actual 1, expected 0 +3964: actual 1, expected 0 +3965: actual 1, expected 0 +3966: actual 1, expected 0 +3968: actual 1, expected 0 +3969: actual 1, expected 0 +3970: actual 1, expected 0 +3971: actual 1, expected 0 +3972: actual 1, expected 0 +3974: actual 1, expected 0 +3975: actual 1, expected 0 +3981: actual 1, expected 0 +3982: actual 1, expected 0 +3983: actual 1, expected 0 +3984: actual 1, expected 0 +3985: actual 1, expected 0 +3986: actual 1, expected 0 +3987: actual 1, expected 0 +3988: actual 1, expected 0 +3989: actual 1, expected 0 +3990: actual 1, expected 0 +3991: actual 1, expected 0 +3993: actual 1, expected 0 +3994: actual 1, expected 0 +3995: actual 1, expected 0 +3996: actual 1, expected 0 +3997: actual 1, expected 0 +3998: actual 1, expected 0 +3999: actual 1, expected 0 +4000: actual 1, expected 0 +4001: actual 1, expected 0 +4002: actual 1, expected 0 +4003: actual 1, expected 0 +4004: actual 1, expected 0 +4005: actual 1, expected 0 +4006: actual 1, expected 0 +4007: actual 1, expected 0 +4008: actual 1, expected 0 +4009: actual 1, expected 0 +4010: actual 1, expected 0 +4011: actual 1, expected 0 +4012: actual 1, expected 0 +4013: actual 1, expected 0 +4014: actual 1, expected 0 +4015: actual 1, expected 0 +4016: actual 1, expected 0 +4017: actual 1, expected 0 +4018: actual 1, expected 0 +4019: actual 1, expected 0 +4020: actual 1, expected 0 +4021: actual 1, expected 0 +4022: actual 1, expected 0 +4023: actual 1, expected 0 +4024: actual 1, expected 0 +4025: actual 1, expected 0 +4026: actual 1, expected 0 +4027: actual 1, expected 0 +4028: actual 1, expected 0 +4038: actual 1, expected 0 +11647: actual 1, expected 0 +70835: actual 1, expected 0 +70836: actual 1, expected 0 +70837: actual 1, expected 0 +70838: actual 1, expected 0 +70839: actual 1, expected 0 +70840: actual 1, expected 0 +70842: actual 1, expected 0 +70847: actual 1, expected 0 +70848: actual 1, expected 0 +70850: actual 1, expected 0 +70851: actual 1, expected 0 +123566: actual 1, expected 0 +128726: actual 1, expected 2 +128727: actual 1, expected 2 +128733: actual 1, expected 2 +128734: actual 1, expected 2 +128735: actual 1, expected 2 +128763: actual 1, expected 2 +128764: actual 1, expected 2 +65024: actual 1, expected 0 +65025: actual 1, expected 0 +65026: actual 1, expected 0 +65027: actual 1, expected 0 +65028: actual 1, expected 0 +65029: actual 1, expected 0 +65030: actual 1, expected 0 +65031: actual 1, expected 0 +65032: actual 1, expected 0 +65033: actual 1, expected 0 +65034: actual 1, expected 0 +65035: actual 1, expected 0 +65036: actual 1, expected 0 +65037: actual 1, expected 0 +65038: actual 1, expected 0 +65039: actual 1, expected 0 +917760: actual 1, expected 0 +917761: actual 1, expected 0 +917762: actual 1, expected 0 +917763: actual 1, expected 0 +917764: actual 1, expected 0 +917765: actual 1, expected 0 +917766: actual 1, expected 0 +917767: actual 1, expected 0 +917768: actual 1, expected 0 +917769: actual 1, expected 0 +917770: actual 1, expected 0 +917771: actual 1, expected 0 +917772: actual 1, expected 0 +917773: actual 1, expected 0 +917774: actual 1, expected 0 +917775: actual 1, expected 0 +917776: actual 1, expected 0 +917777: actual 1, expected 0 +917778: actual 1, expected 0 +917779: actual 1, expected 0 +917780: actual 1, expected 0 +917781: actual 1, expected 0 +917782: actual 1, expected 0 +917783: actual 1, expected 0 +917784: actual 1, expected 0 +917785: actual 1, expected 0 +917786: actual 1, expected 0 +917787: actual 1, expected 0 +917788: actual 1, expected 0 +917789: actual 1, expected 0 +917790: actual 1, expected 0 +917791: actual 1, expected 0 +917792: actual 1, expected 0 +917793: actual 1, expected 0 +917794: actual 1, expected 0 +917795: actual 1, expected 0 +917796: actual 1, expected 0 +917797: actual 1, expected 0 +917798: actual 1, expected 0 +917799: actual 1, expected 0 +917800: actual 1, expected 0 +917801: actual 1, expected 0 +917802: actual 1, expected 0 +917803: actual 1, expected 0 +917804: actual 1, expected 0 +917805: actual 1, expected 0 +917806: actual 1, expected 0 +917807: actual 1, expected 0 +917808: actual 1, expected 0 +917809: actual 1, expected 0 +917810: actual 1, expected 0 +917811: actual 1, expected 0 +917812: actual 1, expected 0 +917813: actual 1, expected 0 +917814: actual 1, expected 0 +917815: actual 1, expected 0 +917816: actual 1, expected 0 +917817: actual 1, expected 0 +917818: actual 1, expected 0 +917819: actual 1, expected 0 +917820: actual 1, expected 0 +917821: actual 1, expected 0 +917822: actual 1, expected 0 +917823: actual 1, expected 0 +917824: actual 1, expected 0 +917825: actual 1, expected 0 +917826: actual 1, expected 0 +917827: actual 1, expected 0 +917828: actual 1, expected 0 +917829: actual 1, expected 0 +917830: actual 1, expected 0 +917831: actual 1, expected 0 +917832: actual 1, expected 0 +917833: actual 1, expected 0 +917834: actual 1, expected 0 +917835: actual 1, expected 0 +917836: actual 1, expected 0 +917837: actual 1, expected 0 +917838: actual 1, expected 0 +917839: actual 1, expected 0 +917840: actual 1, expected 0 +917841: actual 1, expected 0 +917842: actual 1, expected 0 +917843: actual 1, expected 0 +917844: actual 1, expected 0 +917845: actual 1, expected 0 +917846: actual 1, expected 0 +917847: actual 1, expected 0 +917848: actual 1, expected 0 +917849: actual 1, expected 0 +917850: actual 1, expected 0 +917851: actual 1, expected 0 +917852: actual 1, expected 0 +917853: actual 1, expected 0 +917854: actual 1, expected 0 +917855: actual 1, expected 0 +917856: actual 1, expected 0 +917857: actual 1, expected 0 +917858: actual 1, expected 0 +917859: actual 1, expected 0 +917860: actual 1, expected 0 +917861: actual 1, expected 0 +917862: actual 1, expected 0 +917863: actual 1, expected 0 +917864: actual 1, expected 0 +917865: actual 1, expected 0 +917866: actual 1, expected 0 +917867: actual 1, expected 0 +917868: actual 1, expected 0 +917869: actual 1, expected 0 +917870: actual 1, expected 0 +917871: actual 1, expected 0 +917872: actual 1, expected 0 +917873: actual 1, expected 0 +917874: actual 1, expected 0 +917875: actual 1, expected 0 +917876: actual 1, expected 0 +917877: actual 1, expected 0 +917878: actual 1, expected 0 +917879: actual 1, expected 0 +917880: actual 1, expected 0 +917881: actual 1, expected 0 +917882: actual 1, expected 0 +917883: actual 1, expected 0 +917884: actual 1, expected 0 +917885: actual 1, expected 0 +917886: actual 1, expected 0 +917887: actual 1, expected 0 +917888: actual 1, expected 0 +917889: actual 1, expected 0 +917890: actual 1, expected 0 +917891: actual 1, expected 0 +917892: actual 1, expected 0 +917893: actual 1, expected 0 +917894: actual 1, expected 0 +917895: actual 1, expected 0 +917896: actual 1, expected 0 +917897: actual 1, expected 0 +917898: actual 1, expected 0 +917899: actual 1, expected 0 +917900: actual 1, expected 0 +917901: actual 1, expected 0 +917902: actual 1, expected 0 +917903: actual 1, expected 0 +917904: actual 1, expected 0 +917905: actual 1, expected 0 +917906: actual 1, expected 0 +917907: actual 1, expected 0 +917908: actual 1, expected 0 +917909: actual 1, expected 0 +917910: actual 1, expected 0 +917911: actual 1, expected 0 +917912: actual 1, expected 0 +917913: actual 1, expected 0 +917914: actual 1, expected 0 +917915: actual 1, expected 0 +917916: actual 1, expected 0 +917917: actual 1, expected 0 +917918: actual 1, expected 0 +917919: actual 1, expected 0 +917920: actual 1, expected 0 +917921: actual 1, expected 0 +917922: actual 1, expected 0 +917923: actual 1, expected 0 +917924: actual 1, expected 0 +917925: actual 1, expected 0 +917926: actual 1, expected 0 +917927: actual 1, expected 0 +917928: actual 1, expected 0 +917929: actual 1, expected 0 +917930: actual 1, expected 0 +917931: actual 1, expected 0 +917932: actual 1, expected 0 +917933: actual 1, expected 0 +917934: actual 1, expected 0 +917935: actual 1, expected 0 +917936: actual 1, expected 0 +917937: actual 1, expected 0 +917938: actual 1, expected 0 +917939: actual 1, expected 0 +917940: actual 1, expected 0 +917941: actual 1, expected 0 +917942: actual 1, expected 0 +917943: actual 1, expected 0 +917944: actual 1, expected 0 +917945: actual 1, expected 0 +917946: actual 1, expected 0 +917947: actual 1, expected 0 +917948: actual 1, expected 0 +917949: actual 1, expected 0 +917950: actual 1, expected 0 +917951: actual 1, expected 0 +917952: actual 1, expected 0 +917953: actual 1, expected 0 +917954: actual 1, expected 0 +917955: actual 1, expected 0 +917956: actual 1, expected 0 +917957: actual 1, expected 0 +917958: actual 1, expected 0 +917959: actual 1, expected 0 +917960: actual 1, expected 0 +917961: actual 1, expected 0 +917962: actual 1, expected 0 +917963: actual 1, expected 0 +917964: actual 1, expected 0 +917965: actual 1, expected 0 +917966: actual 1, expected 0 +917967: actual 1, expected 0 +917968: actual 1, expected 0 +917969: actual 1, expected 0 +917970: actual 1, expected 0 +917971: actual 1, expected 0 +917972: actual 1, expected 0 +917973: actual 1, expected 0 +917974: actual 1, expected 0 +917975: actual 1, expected 0 +917976: actual 1, expected 0 +917977: actual 1, expected 0 +917978: actual 1, expected 0 +917979: actual 1, expected 0 +917980: actual 1, expected 0 +917981: actual 1, expected 0 +917982: actual 1, expected 0 +917983: actual 1, expected 0 +917984: actual 1, expected 0 +917985: actual 1, expected 0 +917986: actual 1, expected 0 +917987: actual 1, expected 0 +917988: actual 1, expected 0 +917989: actual 1, expected 0 +917990: actual 1, expected 0 +917991: actual 1, expected 0 +917992: actual 1, expected 0 +917993: actual 1, expected 0 +917994: actual 1, expected 0 +917995: actual 1, expected 0 +917996: actual 1, expected 0 +917997: actual 1, expected 0 +917998: actual 1, expected 0 +917999: actual 1, expected 0 +7376: actual 1, expected 0 +7377: actual 1, expected 0 +7378: actual 1, expected 0 +7380: actual 1, expected 0 +7381: actual 1, expected 0 +7382: actual 1, expected 0 +7383: actual 1, expected 0 +7384: actual 1, expected 0 +7385: actual 1, expected 0 +7386: actual 1, expected 0 +7387: actual 1, expected 0 +7388: actual 1, expected 0 +7389: actual 1, expected 0 +7390: actual 1, expected 0 +7391: actual 1, expected 0 +7392: actual 1, expected 0 +7394: actual 1, expected 0 +7395: actual 1, expected 0 +7396: actual 1, expected 0 +7397: actual 1, expected 0 +7398: actual 1, expected 0 +7399: actual 1, expected 0 +7400: actual 1, expected 0 +7405: actual 1, expected 0 +7412: actual 1, expected 0 +7416: actual 1, expected 0 +7417: actual 1, expected 0 +123628: actual 1, expected 0 +123629: actual 1, expected 0 +123630: actual 1, expected 0 +123631: actual 1, expected 0 +69291: actual 1, expected 0 +69292: actual 1, expected 0 +72193: actual 1, expected 0 +72194: actual 1, expected 0 +72195: actual 1, expected 0 +72196: actual 1, expected 0 +72197: actual 1, expected 0 +72198: actual 1, expected 0 +72199: actual 1, expected 0 +72200: actual 1, expected 0 +72201: actual 1, expected 0 +72202: actual 1, expected 0 +72243: actual 1, expected 0 +72244: actual 1, expected 0 +72245: actual 1, expected 0 +72246: actual 1, expected 0 +72247: actual 1, expected 0 +72248: actual 1, expected 0 +72251: actual 1, expected 0 +72252: actual 1, expected 0 +72253: actual 1, expected 0 +72254: actual 1, expected 0 +72263: actual 1, expected 0 +118528: actual 1, expected 0 +118529: actual 1, expected 0 +118530: actual 1, expected 0 +118531: actual 1, expected 0 +118532: actual 1, expected 0 +118533: actual 1, expected 0 +118534: actual 1, expected 0 +118535: actual 1, expected 0 +118536: actual 1, expected 0 +118537: actual 1, expected 0 +118538: actual 1, expected 0 +118539: actual 1, expected 0 +118540: actual 1, expected 0 +118541: actual 1, expected 0 +118542: actual 1, expected 0 +118543: actual 1, expected 0 +118544: actual 1, expected 0 +118545: actual 1, expected 0 +118546: actual 1, expected 0 +118547: actual 1, expected 0 +118548: actual 1, expected 0 +118549: actual 1, expected 0 +118550: actual 1, expected 0 +118551: actual 1, expected 0 +118552: actual 1, expected 0 +118553: actual 1, expected 0 +118554: actual 1, expected 0 +118555: actual 1, expected 0 +118556: actual 1, expected 0 +118557: actual 1, expected 0 +118558: actual 1, expected 0 +118559: actual 1, expected 0 +118560: actual 1, expected 0 +118561: actual 1, expected 0 +118562: actual 1, expected 0 +118563: actual 1, expected 0 +118564: actual 1, expected 0 +118565: actual 1, expected 0 +118566: actual 1, expected 0 +118567: actual 1, expected 0 +118568: actual 1, expected 0 +118569: actual 1, expected 0 +118570: actual 1, expected 0 +118571: actual 1, expected 0 +118572: actual 1, expected 0 +118573: actual 1, expected 0 +118576: actual 1, expected 0 +118577: actual 1, expected 0 +118578: actual 1, expected 0 +118579: actual 1, expected 0 +118580: actual 1, expected 0 +118581: actual 1, expected 0 +118582: actual 1, expected 0 +118583: actual 1, expected 0 +118584: actual 1, expected 0 +118585: actual 1, expected 0 +118586: actual 1, expected 0 +118587: actual 1, expected 0 +118588: actual 1, expected 0 +118589: actual 1, expected 0 +118590: actual 1, expected 0 +118591: actual 1, expected 0 +118592: actual 1, expected 0 +118593: actual 1, expected 0 +118594: actual 1, expected 0 +118595: actual 1, expected 0 +118596: actual 1, expected 0 +118597: actual 1, expected 0 +118598: actual 1, expected 0 diff --git a/widths-kitty b/widths-kitty new file mode 100644 index 0000000..e63d5bd --- /dev/null +++ b/widths-kitty @@ -0,0 +1,726 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +71456: actual 0, expected 1 +71457: actual 0, expected 1 +71462: actual 0, expected 1 +64976: actual 0, expected 1 +64977: actual 0, expected 1 +64978: actual 0, expected 1 +64979: actual 0, expected 1 +64980: actual 0, expected 1 +64981: actual 0, expected 1 +64982: actual 0, expected 1 +64983: actual 0, expected 1 +64984: actual 0, expected 1 +64985: actual 0, expected 1 +64986: actual 0, expected 1 +64987: actual 0, expected 1 +64988: actual 0, expected 1 +64989: actual 0, expected 1 +64990: actual 0, expected 1 +64991: actual 0, expected 1 +64992: actual 0, expected 1 +64993: actual 0, expected 1 +64994: actual 0, expected 1 +64995: actual 0, expected 1 +64996: actual 0, expected 1 +64997: actual 0, expected 1 +64998: actual 0, expected 1 +64999: actual 0, expected 1 +65000: actual 0, expected 1 +65001: actual 0, expected 1 +65002: actual 0, expected 1 +65003: actual 0, expected 1 +65004: actual 0, expected 1 +65005: actual 0, expected 1 +65006: actual 0, expected 1 +65007: actual 0, expected 1 +6916: actual 0, expected 1 +6965: actual 0, expected 1 +6971: actual 0, expected 1 +6973: actual 0, expected 1 +6974: actual 0, expected 1 +6975: actual 0, expected 1 +6976: actual 0, expected 1 +6977: actual 0, expected 1 +6979: actual 0, expected 1 +6980: actual 0, expected 1 +7143: actual 0, expected 1 +7146: actual 0, expected 1 +7147: actual 0, expected 1 +7148: actual 0, expected 1 +7150: actual 0, expected 1 +7154: actual 0, expected 1 +7155: actual 0, expected 1 +2434: actual 0, expected 1 +2435: actual 0, expected 1 +2494: actual 0, expected 1 +2495: actual 0, expected 1 +2496: actual 0, expected 1 +2503: actual 0, expected 1 +2504: actual 0, expected 1 +2507: actual 0, expected 1 +2508: actual 0, expected 1 +2519: actual 0, expected 1 +72751: actual 0, expected 1 +72766: actual 0, expected 1 +69632: actual 0, expected 1 +69634: actual 0, expected 1 +6681: actual 0, expected 1 +6682: actual 0, expected 1 +69932: actual 0, expected 1 +69957: actual 0, expected 1 +69958: actual 0, expected 1 +43567: actual 0, expected 1 +43568: actual 0, expected 1 +43571: actual 0, expected 1 +43572: actual 0, expected 1 +43597: actual 0, expected 1 +12334: actual 0, expected 2 +12335: actual 0, expected 2 +12336: actual 1, expected 2 +12349: actual 1, expected 2 +2307: actual 0, expected 1 +2363: actual 0, expected 1 +2366: actual 0, expected 1 +2367: actual 0, expected 1 +2368: actual 0, expected 1 +2377: actual 0, expected 1 +2378: actual 0, expected 1 +2379: actual 0, expected 1 +2380: actual 0, expected 1 +2382: actual 0, expected 1 +2383: actual 0, expected 1 +71984: actual 0, expected 1 +71985: actual 0, expected 1 +71986: actual 0, expected 1 +71987: actual 0, expected 1 +71988: actual 0, expected 1 +71989: actual 0, expected 1 +71991: actual 0, expected 1 +71992: actual 0, expected 1 +71997: actual 0, expected 1 +72000: actual 0, expected 1 +72002: actual 0, expected 1 +71724: actual 0, expected 1 +71725: actual 0, expected 1 +71726: actual 0, expected 1 +71736: actual 0, expected 1 +127462: actual 2, expected 1 +127463: actual 2, expected 1 +127464: actual 2, expected 1 +127465: actual 2, expected 1 +127466: actual 2, expected 1 +127467: actual 2, expected 1 +127468: actual 2, expected 1 +127469: actual 2, expected 1 +127470: actual 2, expected 1 +127471: actual 2, expected 1 +127472: actual 2, expected 1 +127473: actual 2, expected 1 +127474: actual 2, expected 1 +127475: actual 2, expected 1 +127476: actual 2, expected 1 +127477: actual 2, expected 1 +127478: actual 2, expected 1 +127479: actual 2, expected 1 +127480: actual 2, expected 1 +127481: actual 2, expected 1 +127482: actual 2, expected 1 +127483: actual 2, expected 1 +127484: actual 2, expected 1 +127485: actual 2, expected 1 +127486: actual 2, expected 1 +127487: actual 2, expected 1 +12951: actual 1, expected 2 +12953: actual 1, expected 2 +127490: actual 1, expected 2 +127543: actual 1, expected 2 +8293: actual 0, expected 1 +70402: actual 0, expected 1 +70403: actual 0, expected 1 +70462: actual 0, expected 1 +70463: actual 0, expected 1 +70465: actual 0, expected 1 +70466: actual 0, expected 1 +70467: actual 0, expected 1 +70468: actual 0, expected 1 +70471: actual 0, expected 1 +70472: actual 0, expected 1 +70475: actual 0, expected 1 +70476: actual 0, expected 1 +70477: actual 0, expected 1 +70487: actual 0, expected 1 +70498: actual 0, expected 1 +70499: actual 0, expected 1 +2691: actual 0, expected 1 +2750: actual 0, expected 1 +2751: actual 0, expected 1 +2752: actual 0, expected 1 +2761: actual 0, expected 1 +2763: actual 0, expected 1 +2764: actual 0, expected 1 +73098: actual 0, expected 1 +73099: actual 0, expected 1 +73100: actual 0, expected 1 +73101: actual 0, expected 1 +73102: actual 0, expected 1 +73107: actual 0, expected 1 +73108: actual 0, expected 1 +73110: actual 0, expected 1 +2563: actual 0, expected 1 +2622: actual 0, expected 1 +2623: actual 0, expected 1 +2624: actual 0, expected 1 +65440: actual 0, expected 1 +12644: actual 0, expected 2 +4447: actual 0, expected 2 +4449: actual 1, expected 0 +4450: actual 1, expected 0 +4451: actual 1, expected 0 +4452: actual 1, expected 0 +4453: actual 1, expected 0 +4454: actual 1, expected 0 +4455: actual 1, expected 0 +4456: actual 1, expected 0 +4457: actual 1, expected 0 +4458: actual 1, expected 0 +4459: actual 1, expected 0 +4460: actual 1, expected 0 +4461: actual 1, expected 0 +4462: actual 1, expected 0 +4463: actual 1, expected 0 +4464: actual 1, expected 0 +4465: actual 1, expected 0 +4466: actual 1, expected 0 +4467: actual 1, expected 0 +4468: actual 1, expected 0 +4469: actual 1, expected 0 +4470: actual 1, expected 0 +4471: actual 1, expected 0 +4472: actual 1, expected 0 +4473: actual 1, expected 0 +4474: actual 1, expected 0 +4475: actual 1, expected 0 +4476: actual 1, expected 0 +4477: actual 1, expected 0 +4478: actual 1, expected 0 +4479: actual 1, expected 0 +4480: actual 1, expected 0 +4481: actual 1, expected 0 +4482: actual 1, expected 0 +4483: actual 1, expected 0 +4484: actual 1, expected 0 +4485: actual 1, expected 0 +4486: actual 1, expected 0 +4487: actual 1, expected 0 +4488: actual 1, expected 0 +4489: actual 1, expected 0 +4490: actual 1, expected 0 +4491: actual 1, expected 0 +4492: actual 1, expected 0 +4493: actual 1, expected 0 +4494: actual 1, expected 0 +4495: actual 1, expected 0 +4496: actual 1, expected 0 +4497: actual 1, expected 0 +4498: actual 1, expected 0 +4499: actual 1, expected 0 +4500: actual 1, expected 0 +4501: actual 1, expected 0 +4502: actual 1, expected 0 +4503: actual 1, expected 0 +4504: actual 1, expected 0 +4505: actual 1, expected 0 +4506: actual 1, expected 0 +4507: actual 1, expected 0 +4508: actual 1, expected 0 +4509: actual 1, expected 0 +4510: actual 1, expected 0 +4511: actual 1, expected 0 +4512: actual 1, expected 0 +4513: actual 1, expected 0 +4514: actual 1, expected 0 +4515: actual 1, expected 0 +4516: actual 1, expected 0 +4517: actual 1, expected 0 +4518: actual 1, expected 0 +4519: actual 1, expected 0 +4520: actual 1, expected 0 +4521: actual 1, expected 0 +4522: actual 1, expected 0 +4523: actual 1, expected 0 +4524: actual 1, expected 0 +4525: actual 1, expected 0 +4526: actual 1, expected 0 +4527: actual 1, expected 0 +4528: actual 1, expected 0 +4529: actual 1, expected 0 +4530: actual 1, expected 0 +4531: actual 1, expected 0 +4532: actual 1, expected 0 +4533: actual 1, expected 0 +4534: actual 1, expected 0 +4535: actual 1, expected 0 +4536: actual 1, expected 0 +4537: actual 1, expected 0 +4538: actual 1, expected 0 +4539: actual 1, expected 0 +4540: actual 1, expected 0 +4541: actual 1, expected 0 +4542: actual 1, expected 0 +4543: actual 1, expected 0 +4544: actual 1, expected 0 +4545: actual 1, expected 0 +4546: actual 1, expected 0 +4547: actual 1, expected 0 +4548: actual 1, expected 0 +4549: actual 1, expected 0 +4550: actual 1, expected 0 +4551: actual 1, expected 0 +4552: actual 1, expected 0 +4553: actual 1, expected 0 +4554: actual 1, expected 0 +4555: actual 1, expected 0 +4556: actual 1, expected 0 +4557: actual 1, expected 0 +4558: actual 1, expected 0 +4559: actual 1, expected 0 +4560: actual 1, expected 0 +4561: actual 1, expected 0 +4562: actual 1, expected 0 +4563: actual 1, expected 0 +4564: actual 1, expected 0 +4565: actual 1, expected 0 +4566: actual 1, expected 0 +4567: actual 1, expected 0 +4568: actual 1, expected 0 +4569: actual 1, expected 0 +4570: actual 1, expected 0 +4571: actual 1, expected 0 +4572: actual 1, expected 0 +4573: actual 1, expected 0 +4574: actual 1, expected 0 +4575: actual 1, expected 0 +4576: actual 1, expected 0 +4577: actual 1, expected 0 +4578: actual 1, expected 0 +4579: actual 1, expected 0 +4580: actual 1, expected 0 +4581: actual 1, expected 0 +4582: actual 1, expected 0 +4583: actual 1, expected 0 +4584: actual 1, expected 0 +4585: actual 1, expected 0 +4586: actual 1, expected 0 +4587: actual 1, expected 0 +4588: actual 1, expected 0 +4589: actual 1, expected 0 +4590: actual 1, expected 0 +4591: actual 1, expected 0 +4592: actual 1, expected 0 +4593: actual 1, expected 0 +4594: actual 1, expected 0 +4595: actual 1, expected 0 +4596: actual 1, expected 0 +4597: actual 1, expected 0 +4598: actual 1, expected 0 +4599: actual 1, expected 0 +4600: actual 1, expected 0 +4601: actual 1, expected 0 +4602: actual 1, expected 0 +4603: actual 1, expected 0 +4604: actual 1, expected 0 +4605: actual 1, expected 0 +4606: actual 1, expected 0 +4607: actual 1, expected 0 +5940: actual 0, expected 1 +94192: actual 0, expected 2 +94193: actual 0, expected 2 +43395: actual 0, expected 1 +43444: actual 0, expected 1 +43445: actual 0, expected 1 +43450: actual 0, expected 1 +43451: actual 0, expected 1 +43454: actual 0, expected 1 +43455: actual 0, expected 1 +43456: actual 0, expected 1 +69762: actual 0, expected 1 +69808: actual 0, expected 1 +69809: actual 0, expected 1 +69810: actual 0, expected 1 +69815: actual 0, expected 1 +69816: actual 0, expected 1 +3202: actual 0, expected 1 +3203: actual 0, expected 1 +3262: actual 0, expected 1 +3264: actual 0, expected 1 +3265: actual 0, expected 1 +3266: actual 0, expected 1 +3267: actual 0, expected 1 +3268: actual 0, expected 1 +3271: actual 0, expected 1 +3272: actual 0, expected 1 +3274: actual 0, expected 1 +3275: actual 0, expected 1 +3285: actual 0, expected 1 +3286: actual 0, expected 1 +6070: actual 0, expected 1 +6078: actual 0, expected 1 +6079: actual 0, expected 1 +6080: actual 0, expected 1 +6081: actual 0, expected 1 +6082: actual 0, expected 1 +6083: actual 0, expected 1 +6084: actual 0, expected 1 +6085: actual 0, expected 1 +6087: actual 0, expected 1 +6088: actual 0, expected 1 +70188: actual 0, expected 1 +70189: actual 0, expected 1 +70190: actual 0, expected 1 +70194: actual 0, expected 1 +70195: actual 0, expected 1 +70197: actual 0, expected 1 +70368: actual 0, expected 1 +70369: actual 0, expected 1 +70370: actual 0, expected 1 +173: actual 0, expected 1 +7204: actual 0, expected 1 +7205: actual 0, expected 1 +7206: actual 0, expected 1 +7207: actual 0, expected 1 +7208: actual 0, expected 1 +7209: actual 0, expected 1 +7210: actual 0, expected 1 +7211: actual 0, expected 1 +7220: actual 0, expected 1 +7221: actual 0, expected 1 +6435: actual 0, expected 1 +6436: actual 0, expected 1 +6437: actual 0, expected 1 +6438: actual 0, expected 1 +6441: actual 0, expected 1 +6442: actual 0, expected 1 +6443: actual 0, expected 1 +6448: actual 0, expected 1 +6449: actual 0, expected 1 +6451: actual 0, expected 1 +6452: actual 0, expected 1 +6453: actual 0, expected 1 +6454: actual 0, expected 1 +6455: actual 0, expected 1 +6456: actual 0, expected 1 +73461: actual 0, expected 1 +73462: actual 0, expected 1 +3330: actual 0, expected 1 +3331: actual 0, expected 1 +3390: actual 0, expected 1 +3391: actual 0, expected 1 +3392: actual 0, expected 1 +3398: actual 0, expected 1 +3399: actual 0, expected 1 +3400: actual 0, expected 1 +3402: actual 0, expected 1 +3403: actual 0, expected 1 +3404: actual 0, expected 1 +3415: actual 0, expected 1 +72873: actual 0, expected 1 +72881: actual 0, expected 1 +72884: actual 0, expected 1 +44003: actual 0, expected 1 +44004: actual 0, expected 1 +44006: actual 0, expected 1 +44007: actual 0, expected 1 +44009: actual 0, expected 1 +44010: actual 0, expected 1 +44012: actual 0, expected 1 +43755: actual 0, expected 1 +43758: actual 0, expected 1 +43759: actual 0, expected 1 +43765: actual 0, expected 1 +94033: actual 0, expected 1 +94034: actual 0, expected 1 +94035: actual 0, expected 1 +94036: actual 0, expected 1 +94037: actual 0, expected 1 +94038: actual 0, expected 1 +94039: actual 0, expected 1 +94040: actual 0, expected 1 +94041: actual 0, expected 1 +94042: actual 0, expected 1 +94043: actual 0, expected 1 +94044: actual 0, expected 1 +94045: actual 0, expected 1 +94046: actual 0, expected 1 +94047: actual 0, expected 1 +94048: actual 0, expected 1 +94049: actual 0, expected 1 +94050: actual 0, expected 1 +94051: actual 0, expected 1 +94052: actual 0, expected 1 +94053: actual 0, expected 1 +94054: actual 0, expected 1 +94055: actual 0, expected 1 +94056: actual 0, expected 1 +94057: actual 0, expected 1 +94058: actual 0, expected 1 +94059: actual 0, expected 1 +94060: actual 0, expected 1 +94061: actual 0, expected 1 +94062: actual 0, expected 1 +94063: actual 0, expected 1 +94064: actual 0, expected 1 +94065: actual 0, expected 1 +94066: actual 0, expected 1 +94067: actual 0, expected 1 +94068: actual 0, expected 1 +94069: actual 0, expected 1 +94070: actual 0, expected 1 +94071: actual 0, expected 1 +94072: actual 0, expected 1 +94073: actual 0, expected 1 +94074: actual 0, expected 1 +94075: actual 0, expected 1 +94076: actual 0, expected 1 +94077: actual 0, expected 1 +94078: actual 0, expected 1 +94079: actual 0, expected 1 +94080: actual 0, expected 1 +94081: actual 0, expected 1 +94082: actual 0, expected 1 +94083: actual 0, expected 1 +94084: actual 0, expected 1 +94085: actual 0, expected 1 +94086: actual 0, expected 1 +94087: actual 0, expected 1 +127995: actual 0, expected 2 +127996: actual 0, expected 2 +127997: actual 0, expected 2 +127998: actual 0, expected 2 +127999: actual 0, expected 2 +71216: actual 0, expected 1 +71217: actual 0, expected 1 +71218: actual 0, expected 1 +71227: actual 0, expected 1 +71228: actual 0, expected 1 +71230: actual 0, expected 1 +119141: actual 0, expected 1 +119142: actual 0, expected 1 +119149: actual 0, expected 1 +119150: actual 0, expected 1 +119151: actual 0, expected 1 +119152: actual 0, expected 1 +119153: actual 0, expected 1 +119154: actual 0, expected 1 +4139: actual 0, expected 1 +4140: actual 0, expected 1 +4145: actual 0, expected 1 +4152: actual 0, expected 1 +4155: actual 0, expected 1 +4156: actual 0, expected 1 +4182: actual 0, expected 1 +4183: actual 0, expected 1 +4194: actual 0, expected 1 +4195: actual 0, expected 1 +4196: actual 0, expected 1 +4199: actual 0, expected 1 +4200: actual 0, expected 1 +4201: actual 0, expected 1 +4202: actual 0, expected 1 +4203: actual 0, expected 1 +4204: actual 0, expected 1 +4205: actual 0, expected 1 +4227: actual 0, expected 1 +4228: actual 0, expected 1 +4231: actual 0, expected 1 +4232: actual 0, expected 1 +4233: actual 0, expected 1 +4234: actual 0, expected 1 +4235: actual 0, expected 1 +4236: actual 0, expected 1 +4239: actual 0, expected 1 +4250: actual 0, expected 1 +4251: actual 0, expected 1 +4252: actual 0, expected 1 +43643: actual 0, expected 1 +43645: actual 0, expected 1 +72145: actual 0, expected 1 +72146: actual 0, expected 1 +72147: actual 0, expected 1 +72156: actual 0, expected 1 +72157: actual 0, expected 1 +72158: actual 0, expected 1 +72159: actual 0, expected 1 +72164: actual 0, expected 1 +70709: actual 0, expected 1 +70710: actual 0, expected 1 +70711: actual 0, expected 1 +70720: actual 0, expected 1 +70721: actual 0, expected 1 +70725: actual 0, expected 1 +2818: actual 0, expected 1 +2819: actual 0, expected 1 +2878: actual 0, expected 1 +2880: actual 0, expected 1 +2887: actual 0, expected 1 +2888: actual 0, expected 1 +2891: actual 0, expected 1 +2892: actual 0, expected 1 +2903: actual 0, expected 1 +43346: actual 0, expected 1 +43347: actual 0, expected 1 +43136: actual 0, expected 1 +43137: actual 0, expected 1 +43188: actual 0, expected 1 +43189: actual 0, expected 1 +43190: actual 0, expected 1 +43191: actual 0, expected 1 +43192: actual 0, expected 1 +43193: actual 0, expected 1 +43194: actual 0, expected 1 +43195: actual 0, expected 1 +43196: actual 0, expected 1 +43197: actual 0, expected 1 +43198: actual 0, expected 1 +43199: actual 0, expected 1 +43200: actual 0, expected 1 +43201: actual 0, expected 1 +43202: actual 0, expected 1 +43203: actual 0, expected 1 +70018: actual 0, expected 1 +70067: actual 0, expected 1 +70068: actual 0, expected 1 +70069: actual 0, expected 1 +70079: actual 0, expected 1 +70080: actual 0, expected 1 +70094: actual 0, expected 1 +71087: actual 0, expected 1 +71088: actual 0, expected 1 +71089: actual 0, expected 1 +71096: actual 0, expected 1 +71097: actual 0, expected 1 +71098: actual 0, expected 1 +71099: actual 0, expected 1 +71102: actual 0, expected 1 +3458: actual 0, expected 1 +3459: actual 0, expected 1 +3535: actual 0, expected 1 +3536: actual 0, expected 1 +3537: actual 0, expected 1 +3544: actual 0, expected 1 +3545: actual 0, expected 1 +3546: actual 0, expected 1 +3547: actual 0, expected 1 +3548: actual 0, expected 1 +3549: actual 0, expected 1 +3550: actual 0, expected 1 +3551: actual 0, expected 1 +3570: actual 0, expected 1 +3571: actual 0, expected 1 +72279: actual 0, expected 1 +72280: actual 0, expected 1 +72343: actual 0, expected 1 +65520: actual 0, expected 1 +65521: actual 0, expected 1 +65522: actual 0, expected 1 +65523: actual 0, expected 1 +65524: actual 0, expected 1 +65525: actual 0, expected 1 +65526: actual 0, expected 1 +65527: actual 0, expected 1 +65528: actual 0, expected 1 +65534: actual 0, expected 1 +65535: actual 0, expected 1 +7042: actual 0, expected 1 +7073: actual 0, expected 1 +7078: actual 0, expected 1 +7079: actual 0, expected 1 +7082: actual 0, expected 1 +1048574: actual 0, expected 1 +1048575: actual 0, expected 1 +1114110: actual 0, expected 1 +1114111: actual 0, expected 1 +43043: actual 0, expected 1 +43044: actual 0, expected 1 +43047: actual 0, expected 1 +5909: actual 0, expected 1 +917504: actual 0, expected 1 +917506: actual 0, expected 1 +917507: actual 0, expected 1 +917508: actual 0, expected 1 +917509: actual 0, expected 1 +917510: actual 0, expected 1 +917511: actual 0, expected 1 +917512: actual 0, expected 1 +917513: actual 0, expected 1 +917514: actual 0, expected 1 +917515: actual 0, expected 1 +917516: actual 0, expected 1 +917517: actual 0, expected 1 +917518: actual 0, expected 1 +917519: actual 0, expected 1 +917520: actual 0, expected 1 +917521: actual 0, expected 1 +917522: actual 0, expected 1 +917523: actual 0, expected 1 +917524: actual 0, expected 1 +917525: actual 0, expected 1 +917526: actual 0, expected 1 +917527: actual 0, expected 1 +917528: actual 0, expected 1 +917529: actual 0, expected 1 +917530: actual 0, expected 1 +917531: actual 0, expected 1 +917532: actual 0, expected 1 +917533: actual 0, expected 1 +917534: actual 0, expected 1 +917535: actual 0, expected 1 +6741: actual 0, expected 1 +6743: actual 0, expected 1 +6753: actual 0, expected 1 +6755: actual 0, expected 1 +6756: actual 0, expected 1 +6765: actual 0, expected 1 +6766: actual 0, expected 1 +6767: actual 0, expected 1 +6768: actual 0, expected 1 +6769: actual 0, expected 1 +6770: actual 0, expected 1 +71340: actual 0, expected 1 +71342: actual 0, expected 1 +71343: actual 0, expected 1 +71350: actual 0, expected 1 +3006: actual 0, expected 1 +3007: actual 0, expected 1 +3009: actual 0, expected 1 +3010: actual 0, expected 1 +3014: actual 0, expected 1 +3015: actual 0, expected 1 +3016: actual 0, expected 1 +3018: actual 0, expected 1 +3019: actual 0, expected 1 +3020: actual 0, expected 1 +3031: actual 0, expected 1 +3073: actual 0, expected 1 +3074: actual 0, expected 1 +3075: actual 0, expected 1 +3137: actual 0, expected 1 +3138: actual 0, expected 1 +3139: actual 0, expected 1 +3140: actual 0, expected 1 +3902: actual 0, expected 1 +3903: actual 0, expected 1 +3967: actual 0, expected 1 +70832: actual 0, expected 1 +70833: actual 0, expected 1 +70834: actual 0, expected 1 +70841: actual 0, expected 1 +70843: actual 0, expected 1 +70844: actual 0, expected 1 +70845: actual 0, expected 1 +70846: actual 0, expected 1 +70849: actual 0, expected 1 +7393: actual 0, expected 1 +7415: actual 0, expected 1 +72249: actual 0, expected 1 diff --git a/widths-konsole b/widths-konsole new file mode 100644 index 0000000..21b3742 --- /dev/null +++ b/widths-konsole @@ -0,0 +1,260 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +127462: actual 2, expected 1 +127463: actual 2, expected 1 +127464: actual 2, expected 1 +127465: actual 2, expected 1 +127466: actual 2, expected 1 +127467: actual 2, expected 1 +127468: actual 2, expected 1 +127469: actual 2, expected 1 +127470: actual 2, expected 1 +127471: actual 2, expected 1 +127472: actual 2, expected 1 +127473: actual 2, expected 1 +127474: actual 2, expected 1 +127475: actual 2, expected 1 +127476: actual 2, expected 1 +127477: actual 2, expected 1 +127478: actual 2, expected 1 +127479: actual 2, expected 1 +127480: actual 2, expected 1 +127481: actual 2, expected 1 +127482: actual 2, expected 1 +127483: actual 2, expected 1 +127484: actual 2, expected 1 +127485: actual 2, expected 1 +127486: actual 2, expected 1 +127487: actual 2, expected 1 +4448: actual 2, expected 0 +4449: actual 2, expected 0 +4450: actual 2, expected 0 +4451: actual 2, expected 0 +4452: actual 2, expected 0 +4453: actual 2, expected 0 +4454: actual 2, expected 0 +4455: actual 2, expected 0 +4456: actual 2, expected 0 +4457: actual 2, expected 0 +4458: actual 2, expected 0 +4459: actual 2, expected 0 +4460: actual 2, expected 0 +4461: actual 2, expected 0 +4462: actual 2, expected 0 +4463: actual 2, expected 0 +4464: actual 2, expected 0 +4465: actual 2, expected 0 +4466: actual 2, expected 0 +4467: actual 2, expected 0 +4468: actual 2, expected 0 +4469: actual 2, expected 0 +4470: actual 2, expected 0 +4471: actual 2, expected 0 +4472: actual 2, expected 0 +4473: actual 2, expected 0 +4474: actual 2, expected 0 +4475: actual 2, expected 0 +4476: actual 2, expected 0 +4477: actual 2, expected 0 +4478: actual 2, expected 0 +4479: actual 2, expected 0 +4480: actual 2, expected 0 +4481: actual 2, expected 0 +4482: actual 2, expected 0 +4483: actual 2, expected 0 +4484: actual 2, expected 0 +4485: actual 2, expected 0 +4486: actual 2, expected 0 +4487: actual 2, expected 0 +4488: actual 2, expected 0 +4489: actual 2, expected 0 +4490: actual 2, expected 0 +4491: actual 2, expected 0 +4492: actual 2, expected 0 +4493: actual 2, expected 0 +4494: actual 2, expected 0 +4495: actual 2, expected 0 +4496: actual 2, expected 0 +4497: actual 2, expected 0 +4498: actual 2, expected 0 +4499: actual 2, expected 0 +4500: actual 2, expected 0 +4501: actual 2, expected 0 +4502: actual 2, expected 0 +4503: actual 2, expected 0 +4504: actual 2, expected 0 +4505: actual 2, expected 0 +4506: actual 2, expected 0 +4507: actual 2, expected 0 +4508: actual 2, expected 0 +4509: actual 2, expected 0 +4510: actual 2, expected 0 +4511: actual 2, expected 0 +4512: actual 2, expected 0 +4513: actual 2, expected 0 +4514: actual 2, expected 0 +4515: actual 2, expected 0 +4516: actual 2, expected 0 +4517: actual 2, expected 0 +4518: actual 2, expected 0 +4519: actual 2, expected 0 +4520: actual 2, expected 0 +4521: actual 2, expected 0 +4522: actual 2, expected 0 +4523: actual 2, expected 0 +4524: actual 2, expected 0 +4525: actual 2, expected 0 +4526: actual 2, expected 0 +4527: actual 2, expected 0 +4528: actual 2, expected 0 +4529: actual 2, expected 0 +4530: actual 2, expected 0 +4531: actual 2, expected 0 +4532: actual 2, expected 0 +4533: actual 2, expected 0 +4534: actual 2, expected 0 +4535: actual 2, expected 0 +4536: actual 2, expected 0 +4537: actual 2, expected 0 +4538: actual 2, expected 0 +4539: actual 2, expected 0 +4540: actual 2, expected 0 +4541: actual 2, expected 0 +4542: actual 2, expected 0 +4543: actual 2, expected 0 +4544: actual 2, expected 0 +4545: actual 2, expected 0 +4546: actual 2, expected 0 +4547: actual 2, expected 0 +4548: actual 2, expected 0 +4549: actual 2, expected 0 +4550: actual 2, expected 0 +4551: actual 2, expected 0 +4552: actual 2, expected 0 +4553: actual 2, expected 0 +4554: actual 2, expected 0 +4555: actual 2, expected 0 +4556: actual 2, expected 0 +4557: actual 2, expected 0 +4558: actual 2, expected 0 +4559: actual 2, expected 0 +4560: actual 2, expected 0 +4561: actual 2, expected 0 +4562: actual 2, expected 0 +4563: actual 2, expected 0 +4564: actual 2, expected 0 +4565: actual 2, expected 0 +4566: actual 2, expected 0 +4567: actual 2, expected 0 +4568: actual 2, expected 0 +4569: actual 2, expected 0 +4570: actual 2, expected 0 +4571: actual 2, expected 0 +4572: actual 2, expected 0 +4573: actual 2, expected 0 +4574: actual 2, expected 0 +4575: actual 2, expected 0 +4576: actual 2, expected 0 +4577: actual 2, expected 0 +4578: actual 2, expected 0 +4579: actual 2, expected 0 +4580: actual 2, expected 0 +4581: actual 2, expected 0 +4582: actual 2, expected 0 +4583: actual 2, expected 0 +4584: actual 2, expected 0 +4585: actual 2, expected 0 +4586: actual 2, expected 0 +4587: actual 2, expected 0 +4588: actual 2, expected 0 +4589: actual 2, expected 0 +4590: actual 2, expected 0 +4591: actual 2, expected 0 +4592: actual 2, expected 0 +4593: actual 2, expected 0 +4594: actual 2, expected 0 +4595: actual 2, expected 0 +4596: actual 2, expected 0 +4597: actual 2, expected 0 +4598: actual 2, expected 0 +4599: actual 2, expected 0 +4600: actual 2, expected 0 +4601: actual 2, expected 0 +4602: actual 2, expected 0 +4603: actual 2, expected 0 +4604: actual 2, expected 0 +4605: actual 2, expected 0 +4606: actual 2, expected 0 +4607: actual 2, expected 0 +55216: actual 2, expected 1 +55217: actual 2, expected 1 +55218: actual 2, expected 1 +55219: actual 2, expected 1 +55220: actual 2, expected 1 +55221: actual 2, expected 1 +55222: actual 2, expected 1 +55223: actual 2, expected 1 +55224: actual 2, expected 1 +55225: actual 2, expected 1 +55226: actual 2, expected 1 +55227: actual 2, expected 1 +55228: actual 2, expected 1 +55229: actual 2, expected 1 +55230: actual 2, expected 1 +55231: actual 2, expected 1 +55232: actual 2, expected 1 +55233: actual 2, expected 1 +55234: actual 2, expected 1 +55235: actual 2, expected 1 +55236: actual 2, expected 1 +55237: actual 2, expected 1 +55238: actual 2, expected 1 +55243: actual 2, expected 1 +55244: actual 2, expected 1 +55245: actual 2, expected 1 +55246: actual 2, expected 1 +55247: actual 2, expected 1 +55248: actual 2, expected 1 +55249: actual 2, expected 1 +55250: actual 2, expected 1 +55251: actual 2, expected 1 +55252: actual 2, expected 1 +55253: actual 2, expected 1 +55254: actual 2, expected 1 +55255: actual 2, expected 1 +55256: actual 2, expected 1 +55257: actual 2, expected 1 +55258: actual 2, expected 1 +55259: actual 2, expected 1 +55260: actual 2, expected 1 +55261: actual 2, expected 1 +55262: actual 2, expected 1 +55263: actual 2, expected 1 +55264: actual 2, expected 1 +55265: actual 2, expected 1 +55266: actual 2, expected 1 +55267: actual 2, expected 1 +55268: actual 2, expected 1 +55269: actual 2, expected 1 +55270: actual 2, expected 1 +55271: actual 2, expected 1 +55272: actual 2, expected 1 +55273: actual 2, expected 1 +55274: actual 2, expected 1 +55275: actual 2, expected 1 +55276: actual 2, expected 1 +55277: actual 2, expected 1 +55278: actual 2, expected 1 +55279: actual 2, expected 1 +55280: actual 2, expected 1 +55281: actual 2, expected 1 +55282: actual 2, expected 1 +55283: actual 2, expected 1 +55284: actual 2, expected 1 +55285: actual 2, expected 1 +55286: actual 2, expected 1 +55287: actual 2, expected 1 +55288: actual 2, expected 1 +55289: actual 2, expected 1 +55290: actual 2, expected 1 +55291: actual 2, expected 1 diff --git a/widths-st b/widths-st new file mode 100644 index 0000000..ee3a86c --- /dev/null +++ b/widths-st @@ -0,0 +1,420 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +1536: actual 1, expected 0 +1537: actual 1, expected 0 +1538: actual 1, expected 0 +1539: actual 1, expected 0 +1540: actual 1, expected 0 +1541: actual 1, expected 0 +1757: actual 1, expected 0 +2250: actual 1, expected 0 +2251: actual 1, expected 0 +2252: actual 1, expected 0 +2253: actual 1, expected 0 +2254: actual 1, expected 0 +2255: actual 1, expected 0 +2256: actual 1, expected 0 +2257: actual 1, expected 0 +2258: actual 1, expected 0 +2274: actual 1, expected 0 +2192: actual 1, expected 0 +2193: actual 1, expected 0 +2200: actual 1, expected 0 +2201: actual 1, expected 0 +2202: actual 1, expected 0 +2203: actual 1, expected 0 +2204: actual 1, expected 0 +2205: actual 1, expected 0 +2206: actual 1, expected 0 +2207: actual 1, expected 0 +69744: actual 1, expected 0 +69747: actual 1, expected 0 +69748: actual 1, expected 0 +64110: actual 1, expected 2 +64111: actual 1, expected 2 +64218: actual 1, expected 2 +64219: actual 1, expected 2 +64220: actual 1, expected 2 +64221: actual 1, expected 2 +64222: actual 1, expected 2 +64223: actual 1, expected 2 +64224: actual 1, expected 2 +64225: actual 1, expected 2 +64226: actual 1, expected 2 +64227: actual 1, expected 2 +64228: actual 1, expected 2 +64229: actual 1, expected 2 +64230: actual 1, expected 2 +64231: actual 1, expected 2 +64232: actual 1, expected 2 +64233: actual 1, expected 2 +64234: actual 1, expected 2 +64235: actual 1, expected 2 +64236: actual 1, expected 2 +64237: actual 1, expected 2 +64238: actual 1, expected 2 +64239: actual 1, expected 2 +64240: actual 1, expected 2 +64241: actual 1, expected 2 +64242: actual 1, expected 2 +64243: actual 1, expected 2 +64244: actual 1, expected 2 +64245: actual 1, expected 2 +64246: actual 1, expected 2 +64247: actual 1, expected 2 +64248: actual 1, expected 2 +64249: actual 1, expected 2 +64250: actual 1, expected 2 +64251: actual 1, expected 2 +64252: actual 1, expected 2 +64253: actual 1, expected 2 +64254: actual 1, expected 2 +64255: actual 1, expected 2 +195102: actual 1, expected 2 +195103: actual 1, expected 2 +40957: actual 1, expected 2 +40958: actual 1, expected 2 +40959: actual 1, expected 2 +173790: actual 1, expected 2 +173791: actual 1, expected 2 +177973: actual 1, expected 2 +177974: actual 1, expected 2 +177975: actual 1, expected 2 +177976: actual 1, expected 2 +177977: actual 1, expected 2 +177978: actual 1, expected 2 +177979: actual 1, expected 2 +177980: actual 1, expected 2 +177981: actual 1, expected 2 +177982: actual 1, expected 2 +177983: actual 1, expected 2 +178206: actual 1, expected 2 +178207: actual 1, expected 2 +183970: actual 1, expected 2 +183971: actual 1, expected 2 +183972: actual 1, expected 2 +183973: actual 1, expected 2 +183974: actual 1, expected 2 +183975: actual 1, expected 2 +183976: actual 1, expected 2 +183977: actual 1, expected 2 +183978: actual 1, expected 2 +183979: actual 1, expected 2 +183980: actual 1, expected 2 +183981: actual 1, expected 2 +183982: actual 1, expected 2 +183983: actual 1, expected 2 +191457: actual 1, expected 2 +191458: actual 1, expected 2 +191459: actual 1, expected 2 +191460: actual 1, expected 2 +191461: actual 1, expected 2 +191462: actual 1, expected 2 +191463: actual 1, expected 2 +191464: actual 1, expected 2 +191465: actual 1, expected 2 +191466: actual 1, expected 2 +191467: actual 1, expected 2 +191468: actual 1, expected 2 +191469: actual 1, expected 2 +191470: actual 1, expected 2 +191471: actual 1, expected 2 +201547: actual 1, expected 2 +201548: actual 1, expected 2 +201549: actual 1, expected 2 +201550: actual 1, expected 2 +201551: actual 1, expected 2 +6849: actual 1, expected 0 +6850: actual 1, expected 0 +6851: actual 1, expected 0 +6852: actual 1, expected 0 +6853: actual 1, expected 0 +6854: actual 1, expected 0 +6855: actual 1, expected 0 +6856: actual 1, expected 0 +6857: actual 1, expected 0 +6858: actual 1, expected 0 +6859: actual 1, expected 0 +6860: actual 1, expected 0 +6861: actual 1, expected 0 +6862: actual 1, expected 0 +7674: actual 1, expected 0 +12872: actual 2, expected 1 +12873: actual 2, expected 1 +12874: actual 2, expected 1 +12875: actual 2, expected 1 +12876: actual 2, expected 1 +12877: actual 2, expected 1 +12878: actual 2, expected 1 +12879: actual 2, expected 1 +129008: actual 1, expected 2 +55216: actual 0, expected 1 +55217: actual 0, expected 1 +55218: actual 0, expected 1 +55219: actual 0, expected 1 +55220: actual 0, expected 1 +55221: actual 0, expected 1 +55222: actual 0, expected 1 +55223: actual 0, expected 1 +55224: actual 0, expected 1 +55225: actual 0, expected 1 +55226: actual 0, expected 1 +55227: actual 0, expected 1 +55228: actual 0, expected 1 +55229: actual 0, expected 1 +55230: actual 0, expected 1 +55231: actual 0, expected 1 +55232: actual 0, expected 1 +55233: actual 0, expected 1 +55234: actual 0, expected 1 +55235: actual 0, expected 1 +55236: actual 0, expected 1 +55237: actual 0, expected 1 +55238: actual 0, expected 1 +55243: actual 0, expected 1 +55244: actual 0, expected 1 +55245: actual 0, expected 1 +55246: actual 0, expected 1 +55247: actual 0, expected 1 +55248: actual 0, expected 1 +55249: actual 0, expected 1 +55250: actual 0, expected 1 +55251: actual 0, expected 1 +55252: actual 0, expected 1 +55253: actual 0, expected 1 +55254: actual 0, expected 1 +55255: actual 0, expected 1 +55256: actual 0, expected 1 +55257: actual 0, expected 1 +55258: actual 0, expected 1 +55259: actual 0, expected 1 +55260: actual 0, expected 1 +55261: actual 0, expected 1 +55262: actual 0, expected 1 +55263: actual 0, expected 1 +55264: actual 0, expected 1 +55265: actual 0, expected 1 +55266: actual 0, expected 1 +55267: actual 0, expected 1 +55268: actual 0, expected 1 +55269: actual 0, expected 1 +55270: actual 0, expected 1 +55271: actual 0, expected 1 +55272: actual 0, expected 1 +55273: actual 0, expected 1 +55274: actual 0, expected 1 +55275: actual 0, expected 1 +55276: actual 0, expected 1 +55277: actual 0, expected 1 +55278: actual 0, expected 1 +55279: actual 0, expected 1 +55280: actual 0, expected 1 +55281: actual 0, expected 1 +55282: actual 0, expected 1 +55283: actual 0, expected 1 +55284: actual 0, expected 1 +55285: actual 0, expected 1 +55286: actual 0, expected 1 +55287: actual 0, expected 1 +55288: actual 0, expected 1 +55289: actual 0, expected 1 +55290: actual 0, expected 1 +55291: actual 0, expected 1 +5940: actual 0, expected 1 +69821: actual 1, expected 0 +69826: actual 1, expected 0 +69837: actual 1, expected 0 +110879: actual 1, expected 2 +110880: actual 1, expected 2 +110881: actual 1, expected 2 +110882: actual 1, expected 2 +110576: actual 1, expected 2 +110577: actual 1, expected 2 +110578: actual 1, expected 2 +110579: actual 1, expected 2 +110581: actual 1, expected 2 +110582: actual 1, expected 2 +110583: actual 1, expected 2 +110584: actual 1, expected 2 +110585: actual 1, expected 2 +110586: actual 1, expected 2 +110587: actual 1, expected 2 +110589: actual 1, expected 2 +110590: actual 1, expected 2 +6159: actual 1, expected 0 +69506: actual 1, expected 0 +69507: actual 1, expected 0 +69508: actual 1, expected 0 +69509: actual 1, expected 0 +129401: actual 1, expected 2 +129484: actual 1, expected 2 +129659: actual 1, expected 2 +129660: actual 1, expected 2 +129705: actual 1, expected 2 +129706: actual 1, expected 2 +129707: actual 1, expected 2 +129708: actual 1, expected 2 +129719: actual 1, expected 2 +129720: actual 1, expected 2 +129721: actual 1, expected 2 +129722: actual 1, expected 2 +129731: actual 1, expected 2 +129732: actual 1, expected 2 +129733: actual 1, expected 2 +129751: actual 1, expected 2 +129752: actual 1, expected 2 +129753: actual 1, expected 2 +129760: actual 1, expected 2 +129761: actual 1, expected 2 +129762: actual 1, expected 2 +129763: actual 1, expected 2 +129764: actual 1, expected 2 +129765: actual 1, expected 2 +129766: actual 1, expected 2 +129767: actual 1, expected 2 +129776: actual 1, expected 2 +129777: actual 1, expected 2 +129778: actual 1, expected 2 +129779: actual 1, expected 2 +129780: actual 1, expected 2 +129781: actual 1, expected 2 +129782: actual 1, expected 2 +1807: actual 1, expected 0 +3132: actual 1, expected 0 +123566: actual 1, expected 0 +128733: actual 1, expected 2 +128734: actual 1, expected 2 +128735: actual 1, expected 2 +19904: actual 2, expected 1 +19905: actual 2, expected 1 +19906: actual 2, expected 1 +19907: actual 2, expected 1 +19908: actual 2, expected 1 +19909: actual 2, expected 1 +19910: actual 2, expected 1 +19911: actual 2, expected 1 +19912: actual 2, expected 1 +19913: actual 2, expected 1 +19914: actual 2, expected 1 +19915: actual 2, expected 1 +19916: actual 2, expected 1 +19917: actual 2, expected 1 +19918: actual 2, expected 1 +19919: actual 2, expected 1 +19920: actual 2, expected 1 +19921: actual 2, expected 1 +19922: actual 2, expected 1 +19923: actual 2, expected 1 +19924: actual 2, expected 1 +19925: actual 2, expected 1 +19926: actual 2, expected 1 +19927: actual 2, expected 1 +19928: actual 2, expected 1 +19929: actual 2, expected 1 +19930: actual 2, expected 1 +19931: actual 2, expected 1 +19932: actual 2, expected 1 +19933: actual 2, expected 1 +19934: actual 2, expected 1 +19935: actual 2, expected 1 +19936: actual 2, expected 1 +19937: actual 2, expected 1 +19938: actual 2, expected 1 +19939: actual 2, expected 1 +19940: actual 2, expected 1 +19941: actual 2, expected 1 +19942: actual 2, expected 1 +19943: actual 2, expected 1 +19944: actual 2, expected 1 +19945: actual 2, expected 1 +19946: actual 2, expected 1 +19947: actual 2, expected 1 +19948: actual 2, expected 1 +19949: actual 2, expected 1 +19950: actual 2, expected 1 +19951: actual 2, expected 1 +19952: actual 2, expected 1 +19953: actual 2, expected 1 +19954: actual 2, expected 1 +19955: actual 2, expected 1 +19956: actual 2, expected 1 +19957: actual 2, expected 1 +19958: actual 2, expected 1 +19959: actual 2, expected 1 +19960: actual 2, expected 1 +19961: actual 2, expected 1 +19962: actual 2, expected 1 +19963: actual 2, expected 1 +19964: actual 2, expected 1 +19965: actual 2, expected 1 +19966: actual 2, expected 1 +19967: actual 2, expected 1 +118528: actual 1, expected 0 +118529: actual 1, expected 0 +118530: actual 1, expected 0 +118531: actual 1, expected 0 +118532: actual 1, expected 0 +118533: actual 1, expected 0 +118534: actual 1, expected 0 +118535: actual 1, expected 0 +118536: actual 1, expected 0 +118537: actual 1, expected 0 +118538: actual 1, expected 0 +118539: actual 1, expected 0 +118540: actual 1, expected 0 +118541: actual 1, expected 0 +118542: actual 1, expected 0 +118543: actual 1, expected 0 +118544: actual 1, expected 0 +118545: actual 1, expected 0 +118546: actual 1, expected 0 +118547: actual 1, expected 0 +118548: actual 1, expected 0 +118549: actual 1, expected 0 +118550: actual 1, expected 0 +118551: actual 1, expected 0 +118552: actual 1, expected 0 +118553: actual 1, expected 0 +118554: actual 1, expected 0 +118555: actual 1, expected 0 +118556: actual 1, expected 0 +118557: actual 1, expected 0 +118558: actual 1, expected 0 +118559: actual 1, expected 0 +118560: actual 1, expected 0 +118561: actual 1, expected 0 +118562: actual 1, expected 0 +118563: actual 1, expected 0 +118564: actual 1, expected 0 +118565: actual 1, expected 0 +118566: actual 1, expected 0 +118567: actual 1, expected 0 +118568: actual 1, expected 0 +118569: actual 1, expected 0 +118570: actual 1, expected 0 +118571: actual 1, expected 0 +118572: actual 1, expected 0 +118573: actual 1, expected 0 +118576: actual 1, expected 0 +118577: actual 1, expected 0 +118578: actual 1, expected 0 +118579: actual 1, expected 0 +118580: actual 1, expected 0 +118581: actual 1, expected 0 +118582: actual 1, expected 0 +118583: actual 1, expected 0 +118584: actual 1, expected 0 +118585: actual 1, expected 0 +118586: actual 1, expected 0 +118587: actual 1, expected 0 +118588: actual 1, expected 0 +118589: actual 1, expected 0 +118590: actual 1, expected 0 +118591: actual 1, expected 0 +118592: actual 1, expected 0 +118593: actual 1, expected 0 +118594: actual 1, expected 0 +118595: actual 1, expected 0 +118596: actual 1, expected 0 +118597: actual 1, expected 0 +118598: actual 1, expected 0 diff --git a/widths-terminator b/widths-terminator new file mode 100644 index 0000000..313d690 --- /dev/null +++ b/widths-terminator @@ -0,0 +1,82 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +55216: actual 0, expected 1 +55217: actual 0, expected 1 +55218: actual 0, expected 1 +55219: actual 0, expected 1 +55220: actual 0, expected 1 +55221: actual 0, expected 1 +55222: actual 0, expected 1 +55223: actual 0, expected 1 +55224: actual 0, expected 1 +55225: actual 0, expected 1 +55226: actual 0, expected 1 +55227: actual 0, expected 1 +55228: actual 0, expected 1 +55229: actual 0, expected 1 +55230: actual 0, expected 1 +55231: actual 0, expected 1 +55232: actual 0, expected 1 +55233: actual 0, expected 1 +55234: actual 0, expected 1 +55235: actual 0, expected 1 +55236: actual 0, expected 1 +55237: actual 0, expected 1 +55238: actual 0, expected 1 +55239: actual 0, expected 1 +55240: actual 0, expected 1 +55241: actual 0, expected 1 +55242: actual 0, expected 1 +55243: actual 0, expected 1 +55244: actual 0, expected 1 +55245: actual 0, expected 1 +55246: actual 0, expected 1 +55247: actual 0, expected 1 +55248: actual 0, expected 1 +55249: actual 0, expected 1 +55250: actual 0, expected 1 +55251: actual 0, expected 1 +55252: actual 0, expected 1 +55253: actual 0, expected 1 +55254: actual 0, expected 1 +55255: actual 0, expected 1 +55256: actual 0, expected 1 +55257: actual 0, expected 1 +55258: actual 0, expected 1 +55259: actual 0, expected 1 +55260: actual 0, expected 1 +55261: actual 0, expected 1 +55262: actual 0, expected 1 +55263: actual 0, expected 1 +55264: actual 0, expected 1 +55265: actual 0, expected 1 +55266: actual 0, expected 1 +55267: actual 0, expected 1 +55268: actual 0, expected 1 +55269: actual 0, expected 1 +55270: actual 0, expected 1 +55271: actual 0, expected 1 +55272: actual 0, expected 1 +55273: actual 0, expected 1 +55274: actual 0, expected 1 +55275: actual 0, expected 1 +55276: actual 0, expected 1 +55277: actual 0, expected 1 +55278: actual 0, expected 1 +55279: actual 0, expected 1 +55280: actual 0, expected 1 +55281: actual 0, expected 1 +55282: actual 0, expected 1 +55283: actual 0, expected 1 +55284: actual 0, expected 1 +55285: actual 0, expected 1 +55286: actual 0, expected 1 +55287: actual 0, expected 1 +55288: actual 0, expected 1 +55289: actual 0, expected 1 +55290: actual 0, expected 1 +55291: actual 0, expected 1 +55292: actual 0, expected 1 +55293: actual 0, expected 1 +55294: actual 0, expected 1 +55295: actual 0, expected 1 diff --git a/widths-termite b/widths-termite new file mode 100644 index 0000000..313d690 --- /dev/null +++ b/widths-termite @@ -0,0 +1,82 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +55216: actual 0, expected 1 +55217: actual 0, expected 1 +55218: actual 0, expected 1 +55219: actual 0, expected 1 +55220: actual 0, expected 1 +55221: actual 0, expected 1 +55222: actual 0, expected 1 +55223: actual 0, expected 1 +55224: actual 0, expected 1 +55225: actual 0, expected 1 +55226: actual 0, expected 1 +55227: actual 0, expected 1 +55228: actual 0, expected 1 +55229: actual 0, expected 1 +55230: actual 0, expected 1 +55231: actual 0, expected 1 +55232: actual 0, expected 1 +55233: actual 0, expected 1 +55234: actual 0, expected 1 +55235: actual 0, expected 1 +55236: actual 0, expected 1 +55237: actual 0, expected 1 +55238: actual 0, expected 1 +55239: actual 0, expected 1 +55240: actual 0, expected 1 +55241: actual 0, expected 1 +55242: actual 0, expected 1 +55243: actual 0, expected 1 +55244: actual 0, expected 1 +55245: actual 0, expected 1 +55246: actual 0, expected 1 +55247: actual 0, expected 1 +55248: actual 0, expected 1 +55249: actual 0, expected 1 +55250: actual 0, expected 1 +55251: actual 0, expected 1 +55252: actual 0, expected 1 +55253: actual 0, expected 1 +55254: actual 0, expected 1 +55255: actual 0, expected 1 +55256: actual 0, expected 1 +55257: actual 0, expected 1 +55258: actual 0, expected 1 +55259: actual 0, expected 1 +55260: actual 0, expected 1 +55261: actual 0, expected 1 +55262: actual 0, expected 1 +55263: actual 0, expected 1 +55264: actual 0, expected 1 +55265: actual 0, expected 1 +55266: actual 0, expected 1 +55267: actual 0, expected 1 +55268: actual 0, expected 1 +55269: actual 0, expected 1 +55270: actual 0, expected 1 +55271: actual 0, expected 1 +55272: actual 0, expected 1 +55273: actual 0, expected 1 +55274: actual 0, expected 1 +55275: actual 0, expected 1 +55276: actual 0, expected 1 +55277: actual 0, expected 1 +55278: actual 0, expected 1 +55279: actual 0, expected 1 +55280: actual 0, expected 1 +55281: actual 0, expected 1 +55282: actual 0, expected 1 +55283: actual 0, expected 1 +55284: actual 0, expected 1 +55285: actual 0, expected 1 +55286: actual 0, expected 1 +55287: actual 0, expected 1 +55288: actual 0, expected 1 +55289: actual 0, expected 1 +55290: actual 0, expected 1 +55291: actual 0, expected 1 +55292: actual 0, expected 1 +55293: actual 0, expected 1 +55294: actual 0, expected 1 +55295: actual 0, expected 1 diff --git a/widths-xterm b/widths-xterm new file mode 100644 index 0000000..e6953fa --- /dev/null +++ b/widths-xterm @@ -0,0 +1,427 @@ + Finished release [optimized] target(s) in 0.02s + Running `target/release/examples/measure_widths` +1536: actual 1, expected 0 +1537: actual 1, expected 0 +1538: actual 1, expected 0 +1539: actual 1, expected 0 +1540: actual 1, expected 0 +1541: actual 1, expected 0 +1757: actual 1, expected 0 +2250: actual 1, expected 0 +2251: actual 1, expected 0 +2252: actual 1, expected 0 +2253: actual 1, expected 0 +2254: actual 1, expected 0 +2255: actual 1, expected 0 +2256: actual 1, expected 0 +2257: actual 1, expected 0 +2258: actual 1, expected 0 +2274: actual 1, expected 0 +2192: actual 1, expected 0 +2193: actual 1, expected 0 +2200: actual 1, expected 0 +2201: actual 1, expected 0 +2202: actual 1, expected 0 +2203: actual 1, expected 0 +2204: actual 1, expected 0 +2205: actual 1, expected 0 +2206: actual 1, expected 0 +2207: actual 1, expected 0 +69744: actual 1, expected 0 +69747: actual 1, expected 0 +69748: actual 1, expected 0 +64110: actual 1, expected 2 +64111: actual 1, expected 2 +64218: actual 1, expected 2 +64219: actual 1, expected 2 +64220: actual 1, expected 2 +64221: actual 1, expected 2 +64222: actual 1, expected 2 +64223: actual 1, expected 2 +64224: actual 1, expected 2 +64225: actual 1, expected 2 +64226: actual 1, expected 2 +64227: actual 1, expected 2 +64228: actual 1, expected 2 +64229: actual 1, expected 2 +64230: actual 1, expected 2 +64231: actual 1, expected 2 +64232: actual 1, expected 2 +64233: actual 1, expected 2 +64234: actual 1, expected 2 +64235: actual 1, expected 2 +64236: actual 1, expected 2 +64237: actual 1, expected 2 +64238: actual 1, expected 2 +64239: actual 1, expected 2 +64240: actual 1, expected 2 +64241: actual 1, expected 2 +64242: actual 1, expected 2 +64243: actual 1, expected 2 +64244: actual 1, expected 2 +64245: actual 1, expected 2 +64246: actual 1, expected 2 +64247: actual 1, expected 2 +64248: actual 1, expected 2 +64249: actual 1, expected 2 +64250: actual 1, expected 2 +64251: actual 1, expected 2 +64252: actual 1, expected 2 +64253: actual 1, expected 2 +64254: actual 1, expected 2 +64255: actual 1, expected 2 +195102: actual 1, expected 2 +195103: actual 1, expected 2 +40957: actual 1, expected 2 +40958: actual 1, expected 2 +40959: actual 1, expected 2 +173790: actual 1, expected 2 +173791: actual 1, expected 2 +177973: actual 1, expected 2 +177974: actual 1, expected 2 +177975: actual 1, expected 2 +177976: actual 1, expected 2 +177977: actual 1, expected 2 +177978: actual 1, expected 2 +177979: actual 1, expected 2 +177980: actual 1, expected 2 +177981: actual 1, expected 2 +177982: actual 1, expected 2 +177983: actual 1, expected 2 +178206: actual 1, expected 2 +178207: actual 1, expected 2 +183970: actual 1, expected 2 +183971: actual 1, expected 2 +183972: actual 1, expected 2 +183973: actual 1, expected 2 +183974: actual 1, expected 2 +183975: actual 1, expected 2 +183976: actual 1, expected 2 +183977: actual 1, expected 2 +183978: actual 1, expected 2 +183979: actual 1, expected 2 +183980: actual 1, expected 2 +183981: actual 1, expected 2 +183982: actual 1, expected 2 +183983: actual 1, expected 2 +191457: actual 1, expected 2 +191458: actual 1, expected 2 +191459: actual 1, expected 2 +191460: actual 1, expected 2 +191461: actual 1, expected 2 +191462: actual 1, expected 2 +191463: actual 1, expected 2 +191464: actual 1, expected 2 +191465: actual 1, expected 2 +191466: actual 1, expected 2 +191467: actual 1, expected 2 +191468: actual 1, expected 2 +191469: actual 1, expected 2 +191470: actual 1, expected 2 +191471: actual 1, expected 2 +201547: actual 1, expected 2 +201548: actual 1, expected 2 +201549: actual 1, expected 2 +201550: actual 1, expected 2 +201551: actual 1, expected 2 +6849: actual 1, expected 0 +6850: actual 1, expected 0 +6851: actual 1, expected 0 +6852: actual 1, expected 0 +6853: actual 1, expected 0 +6854: actual 1, expected 0 +6855: actual 1, expected 0 +6856: actual 1, expected 0 +6857: actual 1, expected 0 +6858: actual 1, expected 0 +6859: actual 1, expected 0 +6860: actual 1, expected 0 +6861: actual 1, expected 0 +6862: actual 1, expected 0 +7674: actual 1, expected 0 +12872: actual 2, expected 1 +12873: actual 2, expected 1 +12874: actual 2, expected 1 +12875: actual 2, expected 1 +12876: actual 2, expected 1 +12877: actual 2, expected 1 +12878: actual 2, expected 1 +12879: actual 2, expected 1 +8206: actual 1, expected 0 +8207: actual 1, expected 0 +8234: actual 1, expected 0 +8235: actual 1, expected 0 +8236: actual 1, expected 0 +8237: actual 1, expected 0 +8238: actual 1, expected 0 +129008: actual 1, expected 2 +55216: actual 0, expected 1 +55217: actual 0, expected 1 +55218: actual 0, expected 1 +55219: actual 0, expected 1 +55220: actual 0, expected 1 +55221: actual 0, expected 1 +55222: actual 0, expected 1 +55223: actual 0, expected 1 +55224: actual 0, expected 1 +55225: actual 0, expected 1 +55226: actual 0, expected 1 +55227: actual 0, expected 1 +55228: actual 0, expected 1 +55229: actual 0, expected 1 +55230: actual 0, expected 1 +55231: actual 0, expected 1 +55232: actual 0, expected 1 +55233: actual 0, expected 1 +55234: actual 0, expected 1 +55235: actual 0, expected 1 +55236: actual 0, expected 1 +55237: actual 0, expected 1 +55238: actual 0, expected 1 +55243: actual 0, expected 1 +55244: actual 0, expected 1 +55245: actual 0, expected 1 +55246: actual 0, expected 1 +55247: actual 0, expected 1 +55248: actual 0, expected 1 +55249: actual 0, expected 1 +55250: actual 0, expected 1 +55251: actual 0, expected 1 +55252: actual 0, expected 1 +55253: actual 0, expected 1 +55254: actual 0, expected 1 +55255: actual 0, expected 1 +55256: actual 0, expected 1 +55257: actual 0, expected 1 +55258: actual 0, expected 1 +55259: actual 0, expected 1 +55260: actual 0, expected 1 +55261: actual 0, expected 1 +55262: actual 0, expected 1 +55263: actual 0, expected 1 +55264: actual 0, expected 1 +55265: actual 0, expected 1 +55266: actual 0, expected 1 +55267: actual 0, expected 1 +55268: actual 0, expected 1 +55269: actual 0, expected 1 +55270: actual 0, expected 1 +55271: actual 0, expected 1 +55272: actual 0, expected 1 +55273: actual 0, expected 1 +55274: actual 0, expected 1 +55275: actual 0, expected 1 +55276: actual 0, expected 1 +55277: actual 0, expected 1 +55278: actual 0, expected 1 +55279: actual 0, expected 1 +55280: actual 0, expected 1 +55281: actual 0, expected 1 +55282: actual 0, expected 1 +55283: actual 0, expected 1 +55284: actual 0, expected 1 +55285: actual 0, expected 1 +55286: actual 0, expected 1 +55287: actual 0, expected 1 +55288: actual 0, expected 1 +55289: actual 0, expected 1 +55290: actual 0, expected 1 +55291: actual 0, expected 1 +5940: actual 0, expected 1 +69821: actual 1, expected 0 +69826: actual 1, expected 0 +69837: actual 1, expected 0 +110879: actual 1, expected 2 +110880: actual 1, expected 2 +110881: actual 1, expected 2 +110882: actual 1, expected 2 +110576: actual 1, expected 2 +110577: actual 1, expected 2 +110578: actual 1, expected 2 +110579: actual 1, expected 2 +110581: actual 1, expected 2 +110582: actual 1, expected 2 +110583: actual 1, expected 2 +110584: actual 1, expected 2 +110585: actual 1, expected 2 +110586: actual 1, expected 2 +110587: actual 1, expected 2 +110589: actual 1, expected 2 +110590: actual 1, expected 2 +6159: actual 1, expected 0 +69506: actual 1, expected 0 +69507: actual 1, expected 0 +69508: actual 1, expected 0 +69509: actual 1, expected 0 +129401: actual 1, expected 2 +129484: actual 1, expected 2 +129659: actual 1, expected 2 +129660: actual 1, expected 2 +129705: actual 1, expected 2 +129706: actual 1, expected 2 +129707: actual 1, expected 2 +129708: actual 1, expected 2 +129719: actual 1, expected 2 +129720: actual 1, expected 2 +129721: actual 1, expected 2 +129722: actual 1, expected 2 +129731: actual 1, expected 2 +129732: actual 1, expected 2 +129733: actual 1, expected 2 +129751: actual 1, expected 2 +129752: actual 1, expected 2 +129753: actual 1, expected 2 +129760: actual 1, expected 2 +129761: actual 1, expected 2 +129762: actual 1, expected 2 +129763: actual 1, expected 2 +129764: actual 1, expected 2 +129765: actual 1, expected 2 +129766: actual 1, expected 2 +129767: actual 1, expected 2 +129776: actual 1, expected 2 +129777: actual 1, expected 2 +129778: actual 1, expected 2 +129779: actual 1, expected 2 +129780: actual 1, expected 2 +129781: actual 1, expected 2 +129782: actual 1, expected 2 +1807: actual 1, expected 0 +3132: actual 1, expected 0 +123566: actual 1, expected 0 +128733: actual 1, expected 2 +128734: actual 1, expected 2 +128735: actual 1, expected 2 +19904: actual 2, expected 1 +19905: actual 2, expected 1 +19906: actual 2, expected 1 +19907: actual 2, expected 1 +19908: actual 2, expected 1 +19909: actual 2, expected 1 +19910: actual 2, expected 1 +19911: actual 2, expected 1 +19912: actual 2, expected 1 +19913: actual 2, expected 1 +19914: actual 2, expected 1 +19915: actual 2, expected 1 +19916: actual 2, expected 1 +19917: actual 2, expected 1 +19918: actual 2, expected 1 +19919: actual 2, expected 1 +19920: actual 2, expected 1 +19921: actual 2, expected 1 +19922: actual 2, expected 1 +19923: actual 2, expected 1 +19924: actual 2, expected 1 +19925: actual 2, expected 1 +19926: actual 2, expected 1 +19927: actual 2, expected 1 +19928: actual 2, expected 1 +19929: actual 2, expected 1 +19930: actual 2, expected 1 +19931: actual 2, expected 1 +19932: actual 2, expected 1 +19933: actual 2, expected 1 +19934: actual 2, expected 1 +19935: actual 2, expected 1 +19936: actual 2, expected 1 +19937: actual 2, expected 1 +19938: actual 2, expected 1 +19939: actual 2, expected 1 +19940: actual 2, expected 1 +19941: actual 2, expected 1 +19942: actual 2, expected 1 +19943: actual 2, expected 1 +19944: actual 2, expected 1 +19945: actual 2, expected 1 +19946: actual 2, expected 1 +19947: actual 2, expected 1 +19948: actual 2, expected 1 +19949: actual 2, expected 1 +19950: actual 2, expected 1 +19951: actual 2, expected 1 +19952: actual 2, expected 1 +19953: actual 2, expected 1 +19954: actual 2, expected 1 +19955: actual 2, expected 1 +19956: actual 2, expected 1 +19957: actual 2, expected 1 +19958: actual 2, expected 1 +19959: actual 2, expected 1 +19960: actual 2, expected 1 +19961: actual 2, expected 1 +19962: actual 2, expected 1 +19963: actual 2, expected 1 +19964: actual 2, expected 1 +19965: actual 2, expected 1 +19966: actual 2, expected 1 +19967: actual 2, expected 1 +118528: actual 1, expected 0 +118529: actual 1, expected 0 +118530: actual 1, expected 0 +118531: actual 1, expected 0 +118532: actual 1, expected 0 +118533: actual 1, expected 0 +118534: actual 1, expected 0 +118535: actual 1, expected 0 +118536: actual 1, expected 0 +118537: actual 1, expected 0 +118538: actual 1, expected 0 +118539: actual 1, expected 0 +118540: actual 1, expected 0 +118541: actual 1, expected 0 +118542: actual 1, expected 0 +118543: actual 1, expected 0 +118544: actual 1, expected 0 +118545: actual 1, expected 0 +118546: actual 1, expected 0 +118547: actual 1, expected 0 +118548: actual 1, expected 0 +118549: actual 1, expected 0 +118550: actual 1, expected 0 +118551: actual 1, expected 0 +118552: actual 1, expected 0 +118553: actual 1, expected 0 +118554: actual 1, expected 0 +118555: actual 1, expected 0 +118556: actual 1, expected 0 +118557: actual 1, expected 0 +118558: actual 1, expected 0 +118559: actual 1, expected 0 +118560: actual 1, expected 0 +118561: actual 1, expected 0 +118562: actual 1, expected 0 +118563: actual 1, expected 0 +118564: actual 1, expected 0 +118565: actual 1, expected 0 +118566: actual 1, expected 0 +118567: actual 1, expected 0 +118568: actual 1, expected 0 +118569: actual 1, expected 0 +118570: actual 1, expected 0 +118571: actual 1, expected 0 +118572: actual 1, expected 0 +118573: actual 1, expected 0 +118576: actual 1, expected 0 +118577: actual 1, expected 0 +118578: actual 1, expected 0 +118579: actual 1, expected 0 +118580: actual 1, expected 0 +118581: actual 1, expected 0 +118582: actual 1, expected 0 +118583: actual 1, expected 0 +118584: actual 1, expected 0 +118585: actual 1, expected 0 +118586: actual 1, expected 0 +118587: actual 1, expected 0 +118588: actual 1, expected 0 +118589: actual 1, expected 0 +118590: actual 1, expected 0 +118591: actual 1, expected 0 +118592: actual 1, expected 0 +118593: actual 1, expected 0 +118594: actual 1, expected 0 +118595: actual 1, expected 0 +118596: actual 1, expected 0 +118597: actual 1, expected 0 +118598: actual 1, expected 0