diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000..7a89179
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,8 @@
+{
+    "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
new file mode 100644
index 0000000..bef60bc
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,70 @@
+# 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 5b3afd6..22967fc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,13 +1,11 @@
 [package]
 name = "toss"
-version = "0.1.0"
+version = "0.3.4"
 edition = "2021"
 
 [dependencies]
-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"
+async-trait = "0.1.83"
+crossterm = "0.28.1"
+unicode-linebreak = "0.1.5"
+unicode-segmentation = "1.12.0"
+unicode-width = "0.2.0"
diff --git a/examples/hello_world.rs b/examples/hello_world.rs
index 57cc976..62c0c75 100644
--- a/examples/hello_world.rs
+++ b/examples/hello_world.rs
@@ -1,39 +1,30 @@
 use crossterm::event::Event;
-use crossterm::style::{ContentStyle, Stylize};
-use toss::frame::{Frame, Pos};
-use toss::terminal::{Redraw, Terminal};
+use crossterm::style::Stylize;
+use toss::{Frame, Pos, Style, Terminal};
 
 fn draw(f: &mut Frame) {
-    f.write(
-        Pos::new(0, 0),
-        "Hello world!",
-        ContentStyle::default().green(),
-    );
+    f.write(Pos::new(0, 0), ("Hello world!", Style::new().green()));
     f.write(
         Pos::new(0, 1),
-        "Press any key to exit",
-        ContentStyle::default().on_dark_blue(),
+        ("Press any key to exit", Style::new().on_dark_blue()),
     );
     f.show_cursor(Pos::new(16, 0));
 }
 
 fn render_frame(term: &mut Terminal) {
-    loop {
-        // Must be called before rendering, otherwise the terminal has out-of-date
-        // size information and will present garbage.
+    let mut dirty = true;
+    while dirty {
         term.autoresize().unwrap();
-
         draw(term.frame());
-
-        if term.present().unwrap() == Redraw::NotRequired {
-            break;
-        }
+        term.present().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
diff --git a/examples/hello_world_widgets.rs b/examples/hello_world_widgets.rs
new file mode 100644
index 0000000..000cf91
--- /dev/null
+++ b/examples/hello_world_widgets.rs
@@ -0,0 +1,47 @@
+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<io::Error> {
+    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
deleted file mode 100644
index 1a05d26..0000000
--- a/examples/measure_widths.rs
+++ /dev/null
@@ -1,375 +0,0 @@
-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 db98bae..c90c4ae 100644
--- a/examples/overlapping_graphemes.rs
+++ b/examples/overlapping_graphemes.rs
@@ -1,79 +1,67 @@
 use crossterm::event::Event;
-use crossterm::style::{ContentStyle, Stylize};
-use toss::frame::{Frame, Pos};
-use toss::terminal::{Redraw, Terminal};
+use crossterm::style::Stylize;
+use toss::{Frame, Pos, Style, 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 = ContentStyle::default().white().on_dark_blue();
-    let over = ContentStyle::default().black().on_dark_yellow();
+    let under = Style::new().white().on_dark_blue();
+    let over = Style::new().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.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.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));
     }
 }
 
 fn render_frame(term: &mut Terminal) {
-    loop {
-        // Must be called before rendering, otherwise the terminal has out-of-date
-        // size information and will present garbage.
+    let mut dirty = true;
+    while dirty {
         term.autoresize().unwrap();
-
         draw(term.frame());
-
-        if term.present().unwrap() == Redraw::NotRequired {
-            break;
-        }
+        term.present().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
diff --git a/examples/text_wrapping.rs b/examples/text_wrapping.rs
index f150142..5292378 100644
--- a/examples/text_wrapping.rs
+++ b/examples/text_wrapping.rs
@@ -1,7 +1,5 @@
 use crossterm::event::Event;
-use crossterm::style::ContentStyle;
-use toss::frame::{Frame, Pos};
-use toss::terminal::{Redraw, Terminal};
+use toss::{Frame, Pos, Styled, Terminal};
 
 fn draw(f: &mut Frame) {
     let text = concat!(
@@ -14,37 +12,46 @@ 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).",
+        "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",
     );
 
-    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(),
-        );
+    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);
     }
 }
 
 fn render_frame(term: &mut Terminal) {
-    loop {
-        // Must be called before rendering, otherwise the terminal has out-of-date
-        // size information and will present garbage.
+    let mut dirty = true;
+    while dirty {
         term.autoresize().unwrap();
-
         draw(term.frame());
-
-        if term.present().unwrap() == Redraw::NotRequired {
-            break;
-        }
+        term.present().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);
+    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 4707b53..022145b 100644
--- a/src/buffer.rs
+++ b/src/buffer.rs
@@ -1,34 +1,8 @@
+use std::ops::Range;
+
 use crossterm::style::ContentStyle;
-use unicode_segmentation::UnicodeSegmentation;
 
-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 }
-    }
-}
+use crate::{Pos, Size, Style, Styled, WidthDb};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Cell {
@@ -49,13 +23,93 @@ impl Default for Cell {
     }
 }
 
-#[derive(Debug, Default)]
+#[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<i32>, Range<i32>)> {
+        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)]
 pub struct Buffer {
     size: Size,
     data: Vec<Cell>,
+    cursor: Option<Pos>,
+
+    /// 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<StackFrame>,
 }
 
 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);
@@ -67,30 +121,65 @@ impl Buffer {
         y * width + x
     }
 
-    pub(crate) fn at(&self, x: u16, y: u16) -> &Cell {
+    /// 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 {
         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.size
+        self.current_frame().size
+    }
+
+    pub fn cursor(&self) -> Option<Pos> {
+        self.cursor.map(|p| self.current_frame().global_to_local(p))
+    }
+
+    pub fn set_cursor(&mut self, pos: Option<Pos>) {
+        self.cursor = pos.map(|p| self.current_frame().local_to_global(p));
     }
 
     /// Resize the buffer and reset its contents.
     ///
     /// The buffer's contents are reset even if the buffer is already the
-    /// correct size.
+    /// correct size. The stack is reset as well.
     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();
@@ -101,58 +190,86 @@ impl Buffer {
             self.data.clear();
             self.data.resize_with(len, Cell::default);
         }
+
+        self.cursor = None;
+
+        self.stack.clear();
     }
 
-    /// Reset the contents of the buffer.
+    /// Reset the contents and stack of the buffer.
     ///
     /// `buf.reset()` is equivalent to `buf.resize(buf.size())`.
     pub fn reset(&mut self) {
-        self.data.fill_with(Cell::default);
+        self.resize(self.size);
     }
 
     /// 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. Works even if the coordinates
-    /// don't point to the beginning of the grapheme.
+    /// 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.
     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;
         }
     }
 
-    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;
+    /// 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
         }
         let y = pos.y as u16;
 
-        for grapheme in content.graphemes(true) {
-            let width = widthdb.grapheme_width(grapheme);
-            if width > 0 {
-                self.write_grapheme(pos.x, y, width, grapheme, style);
+        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);
             }
-            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, 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
+    fn write_grapheme(
+        &mut self,
+        xrange: &Range<i32>,
+        x: i32,
+        y: u16,
+        width: u8,
+        grapheme: &str,
+        style: Style,
+    ) {
+        let min_x = xrange.start;
+        let max_x = xrange.end - 1; // Last possible cell
 
         let start_x = x;
         let end_x = x + width as i32 - 1; // Coordinate of last cell
@@ -163,12 +280,13 @@ 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: style.cover(base_style),
                     width,
                     offset,
                 };
@@ -178,13 +296,21 @@ 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: style.cover(base_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<'_> {
@@ -206,6 +332,9 @@ impl<'a> Iterator for Cells<'a> {
     type Item = (u16, u16, &'a Cell);
 
     fn next(&mut self) -> Option<Self::Item> {
+        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
new file mode 100644
index 0000000..1735746
--- /dev/null
+++ b/src/coords.rs
@@ -0,0 +1,153 @@
+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<Size> 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<Size> 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<Size> 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<Size> 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<Size> 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 f8c46af..e42ba6b 100644
--- a/src/frame.rs
+++ b/src/frame.rs
@@ -1,35 +1,40 @@
 //! Rendering the next frame.
 
-use crossterm::style::ContentStyle;
-
 use crate::buffer::Buffer;
-pub use crate::buffer::{Pos, Size};
-use crate::widthdb::WidthDB;
-use crate::wrap;
+use crate::{Pos, Size, Styled, WidthDb};
 
 #[derive(Debug, Default)]
 pub struct Frame {
-    pub(crate) widthdb: WidthDB,
+    pub(crate) widthdb: WidthDb,
     pub(crate) buffer: Buffer,
-    cursor: Option<Pos>,
+    pub(crate) title: Option<String>,
+    pub(crate) bell: bool,
 }
 
 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.cursor = None;
+        self.title = None;
     }
 
     pub fn cursor(&self) -> Option<Pos> {
-        self.cursor
+        self.buffer.cursor()
     }
 
     pub fn set_cursor(&mut self, pos: Option<Pos>) {
-        self.cursor = pos;
+        self.buffer.set_cursor(pos);
     }
 
     pub fn show_cursor(&mut self, pos: Pos) {
@@ -40,27 +45,19 @@ impl Frame {
         self.set_cursor(None);
     }
 
-    /// 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_title(&mut self, title: Option<String>) {
+        self.title = title;
     }
 
-    /// 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 set_bell(&mut self, bell: bool) {
+        self.bell = bell;
     }
 
-    pub fn wrap(&mut self, text: &str, width: usize) -> Vec<usize> {
-        wrap::wrap(text, width, &mut self.widthdb)
+    pub fn widthdb(&mut self) -> &mut WidthDb {
+        &mut self.widthdb
     }
 
-    pub fn write(&mut self, pos: Pos, content: &str, style: ContentStyle) {
-        self.buffer.write(&mut self.widthdb, pos, content, style);
+    pub fn write<S: Into<Styled>>(&mut self, pos: Pos, styled: S) {
+        self.buffer.write(&mut self.widthdb, pos, &styled.into());
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 9cbdd9f..a204e8c 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,7 +1,29 @@
+#![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;
-pub mod frame;
-pub mod terminal;
+mod coords;
+mod frame;
+mod style;
+mod styled;
+mod terminal;
+mod widget;
+pub mod widgets;
 mod widthdb;
 mod wrap;
 
-pub use wrap::split_at_indices;
+pub use coords::*;
+pub use frame::*;
+pub use style::*;
+pub use styled::*;
+pub use terminal::*;
+pub use widget::*;
+pub use widthdb::*;
diff --git a/src/style.rs b/src/style.rs
new file mode 100644
index 0000000..56c66ce
--- /dev/null
+++ b/src/style.rs
@@ -0,0 +1,60 @@
+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<ContentStyle> for Style {
+    fn as_ref(&self) -> &ContentStyle {
+        &self.content_style
+    }
+}
+
+impl AsMut<ContentStyle> 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
new file mode 100644
index 0000000..33a8285
--- /dev/null
+++ b/src/styled.rs
@@ -0,0 +1,195 @@
+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<S: AsRef<str>>(text: S, style: Style) -> Self {
+        Self::default().then(text, style)
+    }
+
+    pub fn new_plain<S: AsRef<str>>(text: S) -> Self {
+        Self::default().then_plain(text)
+    }
+
+    pub fn then<S: AsRef<str>>(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<S: AsRef<str>>(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<Self> {
+        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<slice::Iter<'a, (Style, usize)>>,
+}
+
+impl<'a> Iterator for StyledGraphemeIndices<'a> {
+    type Item = (usize, Style, &'a str);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        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<String> for Styled {
+    fn from(text: String) -> Self {
+        Self::new_plain(text)
+    }
+}
+
+impl<S: AsRef<str>> From<(S,)> for Styled {
+    fn from((text,): (S,)) -> Self {
+        Self::new_plain(text)
+    }
+}
+
+impl<S: AsRef<str>> From<(S, Style)> for Styled {
+    fn from((text, style): (S, Style)) -> Self {
+        Self::new(text, style)
+    }
+}
+
+impl<S: AsRef<str>> 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 eb5645e..07fe686 100644
--- a/src/terminal.rs
+++ b/src/terminal.rs
@@ -1,22 +1,28 @@
 //! Displaying frames on a terminal.
 
-use std::io::Write;
-use std::{io, mem};
+use std::io::{self, Write};
+use std::mem;
 
 use crossterm::cursor::{Hide, MoveTo, Show};
-use crossterm::style::{PrintStyledContent, StyledContent};
-use crossterm::terminal::{Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen};
+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::{ExecutableCommand, QueueableCommand};
 
-use crate::buffer::{Buffer, Size};
-use crate::frame::Frame;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Redraw {
-    Required,
-    NotRequired,
-}
+use crate::buffer::Buffer;
+use crate::{AsyncWidget, Frame, Size, Widget, WidthDb, WidthEstimationMethod};
 
+/// 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<dyn Write>,
@@ -31,17 +37,17 @@ pub struct Terminal {
 
 impl Drop for Terminal {
     fn drop(&mut self) {
-        let _ = crossterm::terminal::disable_raw_mode();
-        let _ = self.out.execute(LeaveAlternateScreen);
-        let _ = self.out.execute(Show);
+        let _ = self.suspend();
     }
 }
 
 impl Terminal {
+    /// Create a new [`Terminal`] that wraps stdout.
     pub fn new() -> io::Result<Self> {
         Self::with_target(Box::new(io::stdout()))
     }
 
+    /// Create a new terminal wrapping a custom output.
     pub fn with_target(out: Box<dyn Write>) -> io::Result<Self> {
         let mut result = Self {
             out,
@@ -49,13 +55,136 @@ impl Terminal {
             prev_frame_buffer: Buffer::default(),
             full_redraw: true,
         };
-        crossterm::terminal::enable_raw_mode()?;
-        result.out.execute(EnterAlternateScreen)?;
+        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<bool> {
+        if self.frame.widthdb.measuring_required() {
+            self.full_redraw = true;
+            self.frame.widthdb.measure_widths(&mut self.out)?;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
     /// 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 };
@@ -68,42 +197,86 @@ 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.
-    /// Returns `true` if an immediate redraw is required.
+    ///
+    /// Before drawing and presenting a frame, [`Self::measure_widths`] and
+    /// [`Self::autoresize`] should be called.
     ///
     /// 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<Redraw> {
-        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);
-        }
+    pub fn present(&mut self) -> io::Result<()> {
+        self.out.queue(BeginSynchronizedUpdate)?;
+        let result = self.draw_to_screen();
+        self.out.queue(EndSynchronizedUpdate)?;
+        result?;
 
+        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<E, W>(&mut self, widget: W) -> Result<(), E>
+    where
+        E: From<io::Error>,
+        W: Widget<E>,
+    {
+        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<E, W>(&mut self, widget: W) -> Result<(), E>
+    where
+        E: From<io::Error>,
+        W: AsyncWidget<E>,
+    {
+        self.autoresize()?;
+        widget.draw(self.frame()).await?;
+        self.present()?;
+        Ok(())
+    }
+
+    fn draw_to_screen(&mut self) -> io::Result<()> {
         if self.full_redraw {
-            io::stdout().queue(Clear(ClearType::All))?;
+            self.out.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.out.flush()?;
+        self.update_title()?;
+        self.ring_bell()?;
 
-        mem::swap(&mut self.prev_frame_buffer, &mut self.frame.buffer);
-        self.frame.reset();
-
-        Ok(Redraw::NotRequired)
+        Ok(())
     }
 
     fn draw_differences(&mut self) -> io::Result<()> {
@@ -136,4 +309,19 @@ 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
new file mode 100644
index 0000000..356a047
--- /dev/null
+++ b/src/widget.rs
@@ -0,0 +1,127 @@
+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<E> {
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E>;
+
+    fn draw(self, frame: &mut Frame) -> Result<(), E>;
+}
+
+#[async_trait]
+pub trait AsyncWidget<E> {
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E>;
+
+    async fn draw(self, frame: &mut Frame) -> Result<(), E>;
+}
+
+pub trait WidgetExt: Sized {
+    fn background(self) -> Background<Self> {
+        Background::new(self)
+    }
+
+    fn border(self) -> Border<Self> {
+        Border::new(self)
+    }
+
+    fn boxed<'a, E>(self) -> Boxed<'a, E>
+    where
+        Self: Widget<E> + 'a,
+    {
+        Boxed::new(self)
+    }
+
+    fn boxed_send_sync<'a, E>(self) -> BoxedSendSync<'a, E>
+    where
+        Self: Widget<E> + Send + Sync + 'a,
+    {
+        BoxedSendSync::new(self)
+    }
+
+    fn boxed_async<'a, E>(self) -> BoxedAsync<'a, E>
+    where
+        Self: AsyncWidget<E> + Send + Sync + 'a,
+    {
+        BoxedAsync::new(self)
+    }
+
+    fn desync(self) -> Desync<Self> {
+        Desync(self)
+    }
+
+    fn first2<W2>(self) -> Either2<Self, W2> {
+        Either2::First(self)
+    }
+
+    fn second2<W1>(self) -> Either2<W1, Self> {
+        Either2::Second(self)
+    }
+
+    fn first3<W2, W3>(self) -> Either3<Self, W2, W3> {
+        Either3::First(self)
+    }
+
+    fn second3<W1, W3>(self) -> Either3<W1, Self, W3> {
+        Either3::Second(self)
+    }
+
+    fn third3<W1, W2>(self) -> Either3<W1, W2, Self> {
+        Either3::Third(self)
+    }
+
+    fn float(self) -> Float<Self> {
+        Float::new(self)
+    }
+
+    fn segment(self) -> JoinSegment<Self> {
+        JoinSegment::new(self)
+    }
+
+    fn below<W>(self, above: W) -> Layer2<Self, W> {
+        Layer2::new(self, above)
+    }
+
+    fn above<W>(self, below: W) -> Layer2<W, Self> {
+        Layer2::new(below, self)
+    }
+
+    fn padding(self) -> Padding<Self> {
+        Padding::new(self)
+    }
+
+    fn resize(self) -> Resize<Self> {
+        Resize::new(self)
+    }
+
+    fn title<S: ToString>(self, title: S) -> Title<Self> {
+        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<W> WidgetExt for W {}
diff --git a/src/widgets.rs b/src/widgets.rs
new file mode 100644
index 0000000..cbbff7c
--- /dev/null
+++ b/src/widgets.rs
@@ -0,0 +1,35 @@
+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
new file mode 100644
index 0000000..d0ba530
--- /dev/null
+++ b/src/widgets/background.rs
@@ -0,0 +1,71 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Frame, Pos, Size, Style, Widget, WidthDb};
+
+#[derive(Debug, Clone, Copy)]
+pub struct Background<I> {
+    pub inner: I,
+    pub style: Style,
+}
+
+impl<I> Background<I> {
+    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<E, I> Widget<E> for Background<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Background<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..b37fb67
--- /dev/null
+++ b/src/widgets/bell.rs
@@ -0,0 +1,55 @@
+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<E> Widget<E> for Bell<'_> {
+    fn size(
+        &self,
+        _widthdb: &mut WidthDb,
+        _max_width: Option<u16>,
+        _max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..062cd8f
--- /dev/null
+++ b/src/widgets/border.rs
@@ -0,0 +1,201 @@
+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<I> {
+    pub inner: I,
+    pub look: BorderLook,
+    pub style: Style,
+}
+
+impl<I> Border<I> {
+    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<E, I> Widget<E> for Border<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Border<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..3d9713f
--- /dev/null
+++ b/src/widgets/boxed.rs
@@ -0,0 +1,142 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Frame, Size, Widget, WidthDb};
+
+pub struct Boxed<'a, E>(Box<dyn WidgetWrapper<E> + 'a>);
+
+impl<'a, E> Boxed<'a, E> {
+    pub fn new<I>(inner: I) -> Self
+    where
+        I: Widget<E> + 'a,
+    {
+        Self(Box::new(inner))
+    }
+}
+
+impl<E> Widget<E> for Boxed<'_, E> {
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<dyn WidgetWrapper<E> + Send + Sync + 'a>);
+
+impl<'a, E> BoxedSendSync<'a, E> {
+    pub fn new<I>(inner: I) -> Self
+    where
+        I: Widget<E> + Send + Sync + 'a,
+    {
+        Self(Box::new(inner))
+    }
+}
+
+impl<E> Widget<E> for BoxedSendSync<'_, E> {
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<dyn AsyncWidgetWrapper<E> + Send + Sync + 'a>);
+
+impl<'a, E> BoxedAsync<'a, E> {
+    pub fn new<I>(inner: I) -> Self
+    where
+        I: AsyncWidget<E> + Send + Sync + 'a,
+    {
+        Self(Box::new(inner))
+    }
+}
+
+#[async_trait]
+impl<E> AsyncWidget<E> for BoxedAsync<'_, E> {
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E> {
+    fn wrap_size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E>;
+
+    fn wrap_draw(self: Box<Self>, frame: &mut Frame) -> Result<(), E>;
+}
+
+impl<E, W> WidgetWrapper<E> for W
+where
+    W: Widget<E>,
+{
+    fn wrap_size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        self.size(widthdb, max_width, max_height)
+    }
+
+    fn wrap_draw(self: Box<Self>, frame: &mut Frame) -> Result<(), E> {
+        (*self).draw(frame)
+    }
+}
+
+#[async_trait]
+trait AsyncWidgetWrapper<E> {
+    async fn wrap_size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E>;
+
+    async fn wrap_draw(self: Box<Self>, frame: &mut Frame) -> Result<(), E>;
+}
+
+#[async_trait]
+impl<E, W> AsyncWidgetWrapper<E> for W
+where
+    W: AsyncWidget<E> + Send + Sync,
+{
+    async fn wrap_size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        self.size(widthdb, max_width, max_height).await
+    }
+
+    async fn wrap_draw(self: Box<Self>, frame: &mut Frame) -> Result<(), E> {
+        (*self).draw(frame).await
+    }
+}
diff --git a/src/widgets/cursor.rs b/src/widgets/cursor.rs
new file mode 100644
index 0000000..2bb8199
--- /dev/null
+++ b/src/widgets/cursor.rs
@@ -0,0 +1,68 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Frame, Pos, Size, Widget, WidthDb};
+
+#[derive(Debug, Clone, Copy)]
+pub struct Cursor<I> {
+    pub inner: I,
+    pub position: Pos,
+}
+
+impl<I> Cursor<I> {
+    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<E, I> Widget<E> for Cursor<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Cursor<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..67e7488
--- /dev/null
+++ b/src/widgets/desync.rs
@@ -0,0 +1,42 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Widget};
+
+pub struct Desync<I>(pub I);
+
+impl<E, I> Widget<E> for Desync<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut crate::WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<crate::Size, E> {
+        self.0.size(widthdb, max_width, max_height)
+    }
+
+    fn draw(self, frame: &mut crate::Frame) -> Result<(), E> {
+        self.0.draw(frame)
+    }
+}
+
+#[async_trait]
+impl<E, I> AsyncWidget<E> for Desync<I>
+where
+    I: Widget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut crate::WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<crate::Size, E> {
+        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
new file mode 100644
index 0000000..aa36e8e
--- /dev/null
+++ b/src/widgets/editor.rs
@@ -0,0 +1,485 @@
+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<usize> {
+    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<usize> {
+        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<usize> {
+        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<Styled>,
+    pub focus: bool,
+}
+
+impl Editor<'_> {
+    pub fn state(&mut self) -> &mut EditorState {
+        self.state
+    }
+
+    pub fn text(&self) -> &Styled {
+        &self.highlighted
+    }
+
+    pub fn highlight<F>(&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<F>(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<S: Into<Styled>>(mut self, placeholder: S) -> Self {
+        self.hidden = Some(placeholder.into());
+        self
+    }
+
+    pub fn with_hidden_default_placeholder(self) -> Self {
+        self.with_hidden(("<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<u16>) -> Vec<usize> {
+        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<Styled> {
+        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<E> Widget<E> for Editor<'_> {
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        _max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..cb9a55d
--- /dev/null
+++ b/src/widgets/either.rs
@@ -0,0 +1,118 @@
+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<E, $( $ty ),+> Widget<E> for $name< $( $ty ),+ >
+        where
+            $( $ty: Widget<E>, )+
+        {
+            fn size(
+                &self,
+                widthdb: &mut WidthDb,
+                max_width: Option<u16>,
+                max_height: Option<u16>,
+            ) -> Result<Size, E> {
+                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<E, $( $ty ),+> AsyncWidget<E> for $name< $( $ty ),+ >
+        where
+            $( $ty: AsyncWidget<E> + Send + Sync, )+
+        {
+            async fn size(
+                &self,
+                widthdb: &mut WidthDb,
+                max_width: Option<u16>,
+                max_height: Option<u16>,
+            ) -> Result<Size, E> {
+                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
new file mode 100644
index 0000000..5de4fdf
--- /dev/null
+++ b/src/widgets/empty.rs
@@ -0,0 +1,42 @@
+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<E> Widget<E> for Empty {
+    fn size(
+        &self,
+        _widthdb: &mut WidthDb,
+        _max_width: Option<u16>,
+        _max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        Ok(self.size)
+    }
+
+    fn draw(self, _frame: &mut Frame) -> Result<(), E> {
+        Ok(())
+    }
+}
diff --git a/src/widgets/float.rs b/src/widgets/float.rs
new file mode 100644
index 0000000..5cfb349
--- /dev/null
+++ b/src/widgets/float.rs
@@ -0,0 +1,166 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Frame, Pos, Size, Widget, WidthDb};
+
+#[derive(Debug, Clone, Copy)]
+pub struct Float<I> {
+    pub inner: I,
+    horizontal: Option<f32>,
+    vertical: Option<f32>,
+}
+
+impl<I> Float<I> {
+    pub fn new(inner: I) -> Self {
+        Self {
+            inner,
+            horizontal: None,
+            vertical: None,
+        }
+    }
+
+    pub fn horizontal(&self) -> Option<f32> {
+        self.horizontal
+    }
+
+    pub fn set_horizontal(&mut self, position: Option<f32>) {
+        if let Some(position) = position {
+            assert!((0.0..=1.0).contains(&position));
+        }
+        self.horizontal = position;
+    }
+
+    pub fn vertical(&self) -> Option<f32> {
+        self.vertical
+    }
+
+    pub fn set_vertical(&mut self, position: Option<f32>) {
+        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<E, I> Widget<E> for Float<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Float<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..20cd413
--- /dev/null
+++ b/src/widgets/join.rs
@@ -0,0 +1,721 @@
+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<I>(major_minor: (u16, u16), segment: &JoinSegment<I>) -> 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::<Vec<_>>();
+    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::<f32>();
+    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::<f32>();
+    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<I> {
+    pub inner: I,
+    weight: f32,
+    pub growing: bool,
+    pub shrinking: bool,
+}
+
+impl<I> JoinSegment<I> {
+    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<T>(horizontal: bool, w: T, h: T) -> (T, T) {
+    if horizontal {
+        (w, h)
+    } else {
+        (h, w)
+    }
+}
+
+fn from_mm<T>(horizontal: bool, major: T, minor: T) -> (T, T) {
+    if horizontal {
+        (major, minor)
+    } else {
+        (minor, major)
+    }
+}
+
+fn size<E, I: Widget<E>>(
+    horizontal: bool,
+    widthdb: &mut WidthDb,
+    segment: &JoinSegment<I>,
+    major: Option<u16>,
+    minor: Option<u16>,
+) -> 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<E, I: Widget<E>>(
+    horizontal: bool,
+    widthdb: &mut WidthDb,
+    segment: &JoinSegment<I>,
+    balanced: &Segment,
+    minor: Option<u16>,
+) -> Result<(u16, u16), E> {
+    size(horizontal, widthdb, segment, Some(balanced.major), minor)
+}
+
+async fn size_async<E, I: AsyncWidget<E>>(
+    horizontal: bool,
+    widthdb: &mut WidthDb,
+    segment: &JoinSegment<I>,
+    major: Option<u16>,
+    minor: Option<u16>,
+) -> 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<E, I: AsyncWidget<E>>(
+    horizontal: bool,
+    widthdb: &mut WidthDb,
+    segment: &JoinSegment<I>,
+    balanced: &Segment,
+    minor: Option<u16>,
+) -> 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<I> {
+    horizontal: bool,
+    segments: Vec<JoinSegment<I>>,
+}
+
+impl<I> Join<I> {
+    pub fn horizontal(segments: Vec<JoinSegment<I>>) -> Self {
+        Self {
+            horizontal: true,
+            segments,
+        }
+    }
+
+    pub fn vertical(segments: Vec<JoinSegment<I>>) -> Self {
+        Self {
+            horizontal: false,
+            segments,
+        }
+    }
+}
+
+impl<E, I> Widget<E> for Join<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Join<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, $($type),+ > Widget<E> for $name< $($type),+ >
+        where
+            $( $type: Widget<E>, )+
+        {
+            fn size(
+                &self,
+                widthdb: &mut WidthDb,
+                max_width: Option<u16>,
+                max_height: Option<u16>,
+            ) -> Result<Size, E> {
+                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<E, $($type),+ > AsyncWidget<E> for $name< $($type),+ >
+        where
+            E: Send,
+            $( $type: AsyncWidget<E> + Send + Sync, )+
+        {
+            async fn size(
+                &self,
+                widthdb: &mut WidthDb,
+                max_width: Option<u16>,
+                max_height: Option<u16>,
+            ) -> Result<Size, E> {
+                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
new file mode 100644
index 0000000..af3da5e
--- /dev/null
+++ b/src/widgets/layer.rs
@@ -0,0 +1,201 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Frame, Size, Widget, WidthDb};
+
+#[derive(Debug, Clone)]
+pub struct Layer<I> {
+    layers: Vec<I>,
+}
+
+impl<I> Layer<I> {
+    pub fn new(layers: Vec<I>) -> Self {
+        Self { layers }
+    }
+}
+
+impl<E, I> Widget<E> for Layer<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Layer<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, $($type),+ > Widget<E> for $name< $($type),+ >
+        where
+            $( $type: Widget<E>, )+
+        {
+            fn size(
+                &self,
+                widthdb: &mut WidthDb,
+                max_width: Option<u16>,
+                max_height: Option<u16>,
+            ) -> Result<Size, E> {
+                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<E, $($type),+ > AsyncWidget<E> for $name< $($type),+ >
+        where
+            E: Send,
+            $( $type: AsyncWidget<E> + Send + Sync, )+
+        {
+            async fn size(
+                &self,
+                widthdb: &mut WidthDb,
+                max_width: Option<u16>,
+                max_height: Option<u16>,
+            ) -> Result<Size, E> {
+                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
new file mode 100644
index 0000000..be3aff6
--- /dev/null
+++ b/src/widgets/padding.rs
@@ -0,0 +1,133 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Frame, Pos, Size, Widget, WidthDb};
+
+#[derive(Debug, Clone, Copy)]
+pub struct Padding<I> {
+    pub inner: I,
+    pub left: u16,
+    pub right: u16,
+    pub top: u16,
+    pub bottom: u16,
+    pub stretch: bool,
+}
+
+impl<I> Padding<I> {
+    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<E, I> Widget<E> for Padding<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Padding<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..8301f1e
--- /dev/null
+++ b/src/widgets/predrawn.rs
@@ -0,0 +1,74 @@
+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<E, W: Widget<E>>(inner: W, widthdb: &mut WidthDb) -> Result<Self, E> {
+        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<E, W: AsyncWidget<E>>(
+        inner: W,
+        widthdb: &mut WidthDb,
+    ) -> Result<Self, E> {
+        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<E> Widget<E> for Predrawn {
+    fn size(
+        &self,
+        _widthdb: &mut WidthDb,
+        _max_width: Option<u16>,
+        _max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..81e30b5
--- /dev/null
+++ b/src/widgets/resize.rs
@@ -0,0 +1,120 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Frame, Size, Widget, WidthDb};
+
+#[derive(Debug, Clone, Copy)]
+pub struct Resize<I> {
+    pub inner: I,
+    pub min_width: Option<u16>,
+    pub min_height: Option<u16>,
+    pub max_width: Option<u16>,
+    pub max_height: Option<u16>,
+}
+
+impl<I> Resize<I> {
+    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<u16>,
+        mut height: Option<u16>,
+    ) -> (Option<u16>, Option<u16>) {
+        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<E, I> Widget<E> for Resize<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Resize<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..007f4fe
--- /dev/null
+++ b/src/widgets/text.rs
@@ -0,0 +1,68 @@
+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<S: Into<Styled>>(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<u16>) -> Vec<Styled> {
+        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<E> Widget<E> for Text {
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        _max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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
new file mode 100644
index 0000000..c0dc0d4
--- /dev/null
+++ b/src/widgets/title.rs
@@ -0,0 +1,59 @@
+use async_trait::async_trait;
+
+use crate::{AsyncWidget, Frame, Size, Widget, WidthDb};
+
+#[derive(Debug, Clone)]
+pub struct Title<I> {
+    pub inner: I,
+    pub title: String,
+}
+
+impl<I> Title<I> {
+    pub fn new<S: ToString>(inner: I, title: S) -> Self {
+        Self {
+            inner,
+            title: title.to_string(),
+        }
+    }
+}
+
+impl<E, I> Widget<E> for Title<I>
+where
+    I: Widget<E>,
+{
+    fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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<E, I> AsyncWidget<E> for Title<I>
+where
+    I: AsyncWidget<E> + Send + Sync,
+{
+    async fn size(
+        &self,
+        widthdb: &mut WidthDb,
+        max_width: Option<u16>,
+        max_height: Option<u16>,
+    ) -> Result<Size, E> {
+        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 6af28c3..fe5a26e 100644
--- a/src/widthdb.rs
+++ b/src/widthdb.rs
@@ -6,51 +6,129 @@ use crossterm::style::Print;
 use crossterm::terminal::{Clear, ClearType};
 use crossterm::QueueableCommand;
 use unicode_segmentation::UnicodeSegmentation;
-use unicode_width::UnicodeWidthStr;
+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,
+}
 
 /// Measures and stores the with (in terminal coordinates) of graphemes.
-#[derive(Debug, Default)]
-pub struct WidthDB {
+#[derive(Debug)]
+pub struct WidthDb {
+    pub(crate) estimate: WidthEstimationMethod,
+    pub(crate) measure: bool,
+    pub(crate) tab_width: u8,
     known: HashMap<String, u8>,
     requested: HashSet<String>,
 }
 
-impl WidthDB {
+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
+    }
+
     /// 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 {
+    /// 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 {
         assert_eq!(Some(grapheme), grapheme.graphemes(true).next());
-        if let Some(width) = self.known.get(grapheme) {
-            *width
-        } else {
+        if grapheme == "\t" {
+            return self.tab_width_at_column(col);
+        }
+
+        if self.measure {
+            if let Some(width) = self.known.get(grapheme) {
+                return *width;
+            }
             self.requested.insert(grapheme.to_string());
-            grapheme.width() as u8
+        }
+
+        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::<usize>()
+                .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::<usize>()
+                .try_into()
+                .unwrap_or(u8::MAX),
         }
     }
 
     /// 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.
+    /// 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.
     pub fn width(&mut self, s: &str) -> usize {
         let mut total: usize = 0;
         for grapheme in s.graphemes(true) {
-            total += if let Some(width) = self.known.get(grapheme) {
-                (*width).into()
-            } else {
-                self.requested.insert(grapheme.to_string());
-                grapheme.width()
-            };
+            total += self.grapheme_width(grapheme, total) as usize;
         }
         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<usize> {
+        wrap::wrap(self, text, width)
+    }
+
     /// Whether any new graphemes have been seen since the last time
     /// [`Self::measure_widths`] was called.
-    pub fn measuring_required(&self) -> bool {
-        !self.requested.is_empty()
+    pub(crate) fn measuring_required(&self) -> bool {
+        self.measure && !self.requested.is_empty()
     }
 
     /// Measure the width of all new graphemes that have been seen since the
@@ -59,8 +137,20 @@ 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 fn measure_widths(&mut self, out: &mut impl Write) -> io::Result<()> {
+    pub(crate) fn measure_widths(&mut self, out: &mut impl Write) -> io::Result<()> {
+        if !self.measure {
+            return Ok(());
+        }
         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 309214a..a1ef1d4 100644
--- a/src/wrap.rs
+++ b/src/wrap.rs
@@ -3,21 +3,21 @@
 use unicode_linebreak::BreakOpportunity;
 use unicode_segmentation::UnicodeSegmentation;
 
-use crate::widthdb::WidthDB;
+use crate::WidthDb;
 
-// TODO Handle tabs separately?
-// TODO Convert into an iterator?
-pub fn wrap(text: &str, width: usize, widthdb: &mut WidthDB) -> Vec<usize> {
+pub fn wrap(widthdb: &mut WidthDb, text: &str, width: usize) -> Vec<usize> {
     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;
 
-    // Width of the line at the current grapheme
+    // Starting index and width of the line at the current grapheme (with and
+    // without trailing whitespace)
+    let mut current_start = 0;
     let mut current_width = 0;
+    let mut current_width_trimmed = 0;
 
     for (gi, g) in text.grapheme_indices(true) {
         // Advance break options
@@ -36,60 +36,56 @@ pub fn wrap(text: &str, width: usize, widthdb: &mut WidthDB) -> Vec<usize> {
                 BreakOpportunity::Mandatory => {
                     breaks.push(bi);
                     valid_break = None;
-                    valid_break_width = 0;
+                    current_start = bi;
                     current_width = 0;
+                    current_width_trimmed = 0;
                 }
                 BreakOpportunity::Allowed => {
                     valid_break = Some(bi);
-                    valid_break_width = current_width;
                 }
             }
         }
 
-        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.
+        // 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()];
+
                 breaks.push(bi);
-                current_width -= valid_break_width;
                 valid_break = None;
-                valid_break_width = 0;
-            } else {
-                // 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;
-                valid_break_width = 0;
-                current_width = 0;
+                current_start = bi;
+                current_width = widthdb.width(new_line);
+                current_width_trimmed = widthdb.width(new_line.trim_end());
             }
         }
 
-        current_width += grapheme_width;
+        // 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).
+            } else {
+                // Forced break in the middle of a normally non-breakable chunk
+                // because there are no valid break points.
+                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 };
+            }
+        }
     }
 
     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
deleted file mode 100644
index 1bf2ac3..0000000
--- a/widths-alacritty
+++ /dev/null
@@ -1,2 +0,0 @@
-    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
deleted file mode 100644
index fa4aed1..0000000
--- a/widths-cool-retro-term
+++ /dev/null
@@ -1,5118 +0,0 @@
-    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
deleted file mode 100644
index 313d690..0000000
--- a/widths-gnome-terminal
+++ /dev/null
@@ -1,82 +0,0 @@
-    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
deleted file mode 100644
index a905935..0000000
--- a/widths-hyper
+++ /dev/null
@@ -1,2896 +0,0 @@
-    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
deleted file mode 100644
index e63d5bd..0000000
--- a/widths-kitty
+++ /dev/null
@@ -1,726 +0,0 @@
-    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
deleted file mode 100644
index 21b3742..0000000
--- a/widths-konsole
+++ /dev/null
@@ -1,260 +0,0 @@
-    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
deleted file mode 100644
index ee3a86c..0000000
--- a/widths-st
+++ /dev/null
@@ -1,420 +0,0 @@
-    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
deleted file mode 100644
index 313d690..0000000
--- a/widths-terminator
+++ /dev/null
@@ -1,82 +0,0 @@
-    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
deleted file mode 100644
index 313d690..0000000
--- a/widths-termite
+++ /dev/null
@@ -1,82 +0,0 @@
-    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
deleted file mode 100644
index e6953fa..0000000
--- a/widths-xterm
+++ /dev/null
@@ -1,427 +0,0 @@
-    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