Vendor ratatui temporarily (#835)

* Vendor ratatui temporarily

Once https://github.com/tui-rs-revival/ratatui/pull/114 has been merged,
we can undo this! But otherwise we can't publish to crates.io with a git
dependency.

* make tests pass

* Shush.

* these literally just fail in nix, nowhere else

idk how to work with nix properly, and they're also not our tests

36 files changed, 14682 insertions, 0 deletions

diff --git a/src/ratatui/.github/ISSUE_TEMPLATE/bug_report.md b/src/ratatui/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 00000000..0a0f4bc6
--- /dev/null
+++ b/src/ratatui/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,60 @@
+---
+name: Bug report
+about: Create an issue about a bug you encountered
+title: ''
+labels: bug
+assignees: ''
+---
+
+<!--
+Hi there, sorry `ratatui` is not working as expected.
+Please fill this bug report conscientiously.
+A detailed and complete issue is more likely to be processed quickly.
+-->
+
+## Description
+<!--
+A clear and concise description of what the bug is.
+-->
+
+
+## To Reproduce
+<!--
+Try to reduce the issue to a simple code sample exhibiting the problem.
+Ideally, fork the project and add a test or an example.
+-->
+
+
+## Expected behavior
+<!--
+A clear and concise description of what you expected to happen.
+-->
+
+
+## Screenshots
+<!--
+If applicable, add screenshots, gifs or videos to help explain your problem.
+-->
+
+
+## Environment
+<!--
+Add a description of the systems where you are observing the issue. For example:
+- OS: Linux
+- Terminal Emulator: xterm
+- Font: Inconsolata (Patched)
+- Crate version: 0.7
+- Backend: termion
+-->
+
+- OS:
+- Terminal Emulator:
+- Font:
+- Crate version:
+- Backend:
+
+## Additional context
+<!--
+Add any other context about the problem here.
+If you already looked into the issue, include all the leads you have explored.
+-->
diff --git a/src/ratatui/.github/ISSUE_TEMPLATE/config.yml b/src/ratatui/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..3ba13e0c
--- /dev/null
+++ b/src/ratatui/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1 @@
+blank_issues_enabled: false
diff --git a/src/ratatui/.github/ISSUE_TEMPLATE/feature_request.md b/src/ratatui/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 00000000..ae095edb
--- /dev/null
+++ b/src/ratatui/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,32 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: enhancement
+assignees: ''
+
+---
+
+## Problem
+<!--
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+-->
+
+## Solution
+<!--
+A clear and concise description of what you want to happen.
+Things to consider:
+- backward compatibility
+- ease of use of the API (https://rust-lang.github.io/api-guidelines/)
+- consistency with the rest of the crate
+-->
+
+## Alternatives
+<!--
+A clear and concise description of any alternative solutions or features you've considered.
+-->
+
+## Additional context
+<!--
+Add any other context or screenshots about the feature request here.
+-->
diff --git a/src/ratatui/.github/workflows/cd.yml b/src/ratatui/.github/workflows/cd.yml
new file mode 100644
index 00000000..f61e3603
--- /dev/null
+++ b/src/ratatui/.github/workflows/cd.yml
@@ -0,0 +1,19 @@
+name: Continuous Deployment
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+
+jobs:
+  publish:
+    name: Publish on crates.io
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout the repository
+        uses: actions/checkout@v3
+      - name: Publish
+        uses: actions-rs/cargo@v1
+        with:
+          command: publish
+          args: --token ${{ secrets.CARGO_TOKEN }}
diff --git a/src/ratatui/.github/workflows/ci.yml b/src/ratatui/.github/workflows/ci.yml
new file mode 100644
index 00000000..bfa363e9
--- /dev/null
+++ b/src/ratatui/.github/workflows/ci.yml
@@ -0,0 +1,76 @@
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+name: CI
+
+env:
+  CI_CARGO_MAKE_VERSION: 0.35.16
+
+jobs:
+  test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        rust: ["1.59.0", "stable"]
+        include:
+          - os: ubuntu-latest
+            triple: x86_64-unknown-linux-musl
+          - os: windows-latest
+            triple: x86_64-pc-windows-msvc
+          - os: macos-latest
+            triple: x86_64-apple-darwin
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: hecrj/setup-rust-action@50a120e4d34903c2c1383dec0e9b1d349a9cc2b1
+        with:
+          rust-version: ${{ matrix.rust }}
+          components: rustfmt,clippy
+      - uses: actions/checkout@v3
+      - name: Install cargo-make on Linux or macOS
+        if: ${{ runner.os != 'windows' }}
+        shell: bash
+        run: |
+          curl -LO 'https://github.com/sagiegurari/cargo-make/releases/download/${{ env.CI_CARGO_MAKE_VERSION }}/cargo-make-v${{ env.CI_CARGO_MAKE_VERSION }}-${{ matrix.triple }}.zip'
+          unzip 'cargo-make-v${{ env.CI_CARGO_MAKE_VERSION }}-${{ matrix.triple }}.zip'
+          cp 'cargo-make-v${{ env.CI_CARGO_MAKE_VERSION }}-${{ matrix.triple }}/cargo-make' ~/.cargo/bin/
+          cargo make --version
+      - name: Install cargo-make on Windows
+        if: ${{ runner.os == 'windows' }}
+        shell: bash
+        run: |
+          # `cargo-make-v0.35.16-{target}/` directory is created on Linux and macOS, but it is not creatd on Windows.
+          mkdir cargo-make-temporary
+          cd cargo-make-temporary
+          curl -LO 'https://github.com/sagiegurari/cargo-make/releases/download/${{ env.CI_CARGO_MAKE_VERSION }}/cargo-make-v${{ env.CI_CARGO_MAKE_VERSION }}-${{ matrix.triple }}.zip'
+          unzip 'cargo-make-v${{ env.CI_CARGO_MAKE_VERSION }}-${{ matrix.triple }}.zip'
+          cp cargo-make.exe ~/.cargo/bin/
+          cd ..
+          cargo make --version
+      - name: "Format / Build / Test"
+        run: cargo make ci
+        env:
+          RUST_BACKTRACE: full
+
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        if: github.event_name != 'pull_request'
+        uses: actions/checkout@v3
+      - name: Checkout
+        if: github.event_name == 'pull_request'
+        uses: actions/checkout@v3
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+      - name: "Check conventional commits"
+        uses: crate-ci/committed@master
+        with:
+          args: "-vv"
+          commits: "HEAD"
+      - name: "Check typos"
+        uses: crate-ci/typos@master
diff --git a/src/ratatui/.gitignore b/src/ratatui/.gitignore
new file mode 100644
index 00000000..dcb33fbb
--- /dev/null
+++ b/src/ratatui/.gitignore
@@ -0,0 +1,6 @@
+target
+Cargo.lock
+*.log
+*.rs.rustfmt
+.gdb_history
+.idea/
diff --git a/src/ratatui/LICENSE b/src/ratatui/LICENSE
new file mode 100644
index 00000000..7a0657cb
--- /dev/null
+++ b/src/ratatui/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Florian Dehau
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/src/ratatui/README.md b/src/ratatui/README.md
new file mode 100644
index 00000000..05d4adb6
--- /dev/null
+++ b/src/ratatui/README.md
@@ -0,0 +1,136 @@
+# ratatui
+
+An actively maintained `tui`-rs fork.
+
+[![Build Status](https://github.com/tui-rs-revival/ratatui/workflows/CI/badge.svg)](https://github.com/tui-rs-revival/ratatui/actions?query=workflow%3ACI+)
+[![Crate Status](https://img.shields.io/crates/v/ratatui.svg)](https://crates.io/crates/ratatui)
+[![Docs Status](https://docs.rs/ratatui/badge.svg)](https://docs.rs/crate/ratatui/)
+
+<img src="./assets/demo.gif" alt="Demo cast under Linux Termite with Inconsolata font 12pt">
+
+# Install
+
+```toml
+[dependencies]
+tui = { package = "ratatui" }
+```
+
+# What is this fork?
+
+This fork was created to continue maintenance on the original TUI project. The original maintainer had created an [issue](https://github.com/fdehau/tui-rs/issues/654) explaining how he couldn't find time to continue development, which led to us creating this fork.
+
+With that in mind, **we the community** look forward to continuing the work started by [**Florian Dehau.**](https://github.com/fdehau) :rocket:
+
+In order to organize ourselves, we currently use a [discord server](https://discord.gg/pMCEU9hNEj), feel free to join and come chat ! There are also plans to implement a [matrix](https://matrix.org/) bridge in the near future.
+**Discord is not a MUST to contribute,** we follow a pretty standard github centered open source workflow keeping the most important conversations on github, open an issue or PR and it will be addressed. :smile:
+
+Please make sure you read the updated contributing guidelines, especially if you are interested in working on a PR or issue opened in the previous repository.
+
+# Introduction
+
+`ratatui`-rs is a [Rust](https://www.rust-lang.org) library to build rich terminal
+user interfaces and dashboards. It is heavily inspired by the `Javascript`
+library [blessed-contrib](https://github.com/yaronn/blessed-contrib) and the
+`Go` library [termui](https://github.com/gizak/termui).
+
+The library supports multiple backends:
+
+- [crossterm](https://github.com/crossterm-rs/crossterm) [default]
+- [termion](https://github.com/ticki/termion)
+
+The library is based on the principle of immediate rendering with intermediate
+buffers. This means that at each new frame you should build all widgets that are
+supposed to be part of the UI. While providing a great flexibility for rich and
+interactive UI, this may introduce overhead for highly dynamic content. So, the
+implementation try to minimize the number of ansi escapes sequences generated to
+draw the updated UI. In practice, given the speed of `Rust` the overhead rather
+comes from the terminal emulator than the library itself.
+
+Moreover, the library does not provide any input handling nor any event system and
+you may rely on the previously cited libraries to achieve such features.
+
+## Rust version requirements
+
+Since version 0.17.0, `ratatui` requires **rustc version 1.59.0 or greater**.
+
+# Documentation
+
+The documentation can be found on [docs.rs.](https://docs.rs/ratatui)
+
+# Demo
+
+The demo shown in the gif can be run with all available backends.
+
+```
+# crossterm
+cargo run --example demo --release -- --tick-rate 200
+# termion
+cargo run --example demo --no-default-features --features=termion --release -- --tick-rate 200
+```
+
+where `tick-rate` is the UI refresh rate in ms.
+
+The UI code is in [examples/demo/ui.rs](https://github.com/tui-rs-revival/ratatui/blob/main/examples/demo/ui.rs) while the
+application state is in [examples/demo/app.rs](https://github.com/tui-rs-revival/ratatui/blob/main/examples/demo/app.rs).
+
+If the user interface contains glyphs that are not displayed correctly by your terminal, you may want to run
+the demo without those symbols:
+
+```
+cargo run --example demo --release -- --tick-rate 200 --enhanced-graphics false
+```
+
+# Widgets
+
+## Built in
+
+The library comes with the following list of widgets:
+
+- [Block](https://github.com/tui-rs-revival/ratatui/blob/main/examples/block.rs)
+- [Gauge](https://github.com/tui-rs-revival/ratatui/blob/main/examples/gauge.rs)
+- [Sparkline](https://github.com/tui-rs-revival/ratatui/blob/main/examples/sparkline.rs)
+- [Chart](https://github.com/tui-rs-revival/ratatui/blob/main/examples/chart.rs)
+- [BarChart](https://github.com/tui-rs-revival/ratatui/blob/main/examples/barchart.rs)
+- [List](https://github.com/tui-rs-revival/ratatui/blob/main/examples/list.rs)
+- [Table](https://github.com/tui-rs-revival/ratatui/blob/main/examples/table.rs)
+- [Paragraph](https://github.com/tui-rs-revival/ratatui/blob/main/examples/paragraph.rs)
+- [Canvas (with line, point cloud, map)](https://github.com/tui-rs-revival/ratatui/blob/main/examples/canvas.rs)
+- [Tabs](https://github.com/tui-rs-revival/ratatui/blob/main/examples/tabs.rs)
+
+Click on each item to see the source of the example. Run the examples with with
+cargo (e.g. to run the gauge example `cargo run --example gauge`), and quit by pressing `q`.
+
+You can run all examples by running `cargo make run-examples` (require
+`cargo-make` that can be installed with `cargo install cargo-make`).
+
+### Third-party libraries, bootstrapping templates and widgets
+
+- [ansi-to-tui](https://github.com/uttarayan21/ansi-to-tui) — Convert ansi colored text to `tui::text::Text`
+- [color-to-tui](https://github.com/uttarayan21/color-to-tui) — Parse hex colors to `tui::style::Color`
+- [rust-tui-template](https://github.com/orhun/rust-tui-template) — A template for bootstrapping a Rust TUI application with Tui-rs & crossterm
+- [simple-tui-rs](https://github.com/pmsanford/simple-tui-rs) — A simple example tui-rs app
+- [tui-builder](https://github.com/jkelleyrtp/tui-builder) — Batteries-included MVC framework for Tui-rs + Crossterm apps
+- [tui-clap](https://github.com/kegesch/tui-clap-rs) — Use clap-rs together with Tui-rs
+- [tui-log](https://github.com/kegesch/tui-log-rs) — Example of how to use logging with Tui-rs
+- [tui-logger](https://github.com/gin66/tui-logger) — Logger and Widget for Tui-rs
+- [tui-realm](https://github.com/veeso/tui-realm) — Tui-rs framework to build stateful applications with a React/Elm inspired approach
+- [tui-realm-treeview](https://github.com/veeso/tui-realm-treeview) — Treeview component for Tui-realm
+- [tui tree widget](https://github.com/EdJoPaTo/tui-rs-tree-widget) — Tree Widget for Tui-rs
+- [tui-windows](https://github.com/markatk/tui-windows-rs) — Tui-rs abstraction to handle multiple windows and their rendering
+- [tui-textarea](https://github.com/rhysd/tui-textarea): Simple yet powerful multi-line text editor widget supporting several key shortcuts, undo/redo, text search, etc.
+- [tui-rs-tree-widgets](https://github.com/EdJoPaTo/tui-rs-tree-widget): Widget for tree data structures.
+- [tui-input](https://github.com/sayanarijit/tui-input): TUI input library supporting multiple backends and tui-rs.
+
+# Apps
+
+Check out the list of [close to 40 apps](./APPS.md) using `ratatui`!
+
+# Alternatives
+
+You might want to checkout [Cursive](https://github.com/gyscos/Cursive) for an
+alternative solution to build text user interfaces in Rust.
+
+# License
+
+[MIT](LICENSE)
+
diff --git a/src/ratatui/backend/crossterm.rs b/src/ratatui/backend/crossterm.rs
new file mode 100644
index 00000000..3dceb6ad
--- /dev/null
+++ b/src/ratatui/backend/crossterm.rs
@@ -0,0 +1,241 @@
+use crate::ratatui::{
+    backend::{Backend, ClearType},
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
+use crossterm::{
+    cursor::{Hide, MoveTo, Show},
+    execute, queue,
+    style::{
+        Attribute as CAttribute, Color as CColor, Print, SetAttribute, SetBackgroundColor,
+        SetForegroundColor,
+    },
+    terminal::{self, Clear},
+};
+use std::io::{self, Write};
+
+pub struct CrosstermBackend<W: Write> {
+    buffer: W,
+}
+
+impl<W> CrosstermBackend<W>
+where
+    W: Write,
+{
+    pub fn new(buffer: W) -> CrosstermBackend<W> {
+        CrosstermBackend { buffer }
+    }
+}
+
+impl<W> Write for CrosstermBackend<W>
+where
+    W: Write,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.buffer.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.buffer.flush()
+    }
+}
+
+impl<W> Backend for CrosstermBackend<W>
+where
+    W: Write,
+{
+    fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
+    where
+        I: Iterator<Item = (u16, u16, &'a Cell)>,
+    {
+        let mut fg = Color::Reset;
+        let mut bg = Color::Reset;
+        let mut modifier = Modifier::empty();
+        let mut last_pos: Option<(u16, u16)> = None;
+        for (x, y, cell) in content {
+            // Move the cursor if the previous location was not (x - 1, y)
+            if !matches!(last_pos, Some(p) if x == p.0 + 1 && y == p.1) {
+                map_error(queue!(self.buffer, MoveTo(x, y)))?;
+            }
+            last_pos = Some((x, y));
+            if cell.modifier != modifier {
+                let diff = ModifierDiff {
+                    from: modifier,
+                    to: cell.modifier,
+                };
+                diff.queue(&mut self.buffer)?;
+                modifier = cell.modifier;
+            }
+            if cell.fg != fg {
+                let color = CColor::from(cell.fg);
+                map_error(queue!(self.buffer, SetForegroundColor(color)))?;
+                fg = cell.fg;
+            }
+            if cell.bg != bg {
+                let color = CColor::from(cell.bg);
+                map_error(queue!(self.buffer, SetBackgroundColor(color)))?;
+                bg = cell.bg;
+            }
+
+            map_error(queue!(self.buffer, Print(&cell.symbol)))?;
+        }
+
+        map_error(queue!(
+            self.buffer,
+            SetForegroundColor(CColor::Reset),
+            SetBackgroundColor(CColor::Reset),
+            SetAttribute(CAttribute::Reset)
+        ))
+    }
+
+    fn hide_cursor(&mut self) -> io::Result<()> {
+        map_error(execute!(self.buffer, Hide))
+    }
+
+    fn show_cursor(&mut self) -> io::Result<()> {
+        map_error(execute!(self.buffer, Show))
+    }
+
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        crossterm::cursor::position()
+            .map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))
+    }
+
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        map_error(execute!(self.buffer, MoveTo(x, y)))
+    }
+
+    fn clear(&mut self) -> io::Result<()> {
+        self.clear_region(ClearType::All)
+    }
+
+    fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
+        map_error(execute!(
+            self.buffer,
+            Clear(match clear_type {
+                ClearType::All => crossterm::terminal::ClearType::All,
+                ClearType::AfterCursor => crossterm::terminal::ClearType::FromCursorDown,
+                ClearType::BeforeCursor => crossterm::terminal::ClearType::FromCursorUp,
+                ClearType::CurrentLine => crossterm::terminal::ClearType::CurrentLine,
+                ClearType::UntilNewLine => crossterm::terminal::ClearType::UntilNewLine,
+            })
+        ))
+    }
+
+    fn append_lines(&mut self, n: u16) -> io::Result<()> {
+        for _ in 0..n {
+            map_error(queue!(self.buffer, Print("\n")))?;
+        }
+        self.buffer.flush()
+    }
+
+    fn size(&self) -> io::Result<Rect> {
+        let (width, height) =
+            terminal::size().map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))?;
+
+        Ok(Rect::new(0, 0, width, height))
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.buffer.flush()
+    }
+}
+
+fn map_error(error: crossterm::Result<()>) -> io::Result<()> {
+    error.map_err(|e| io::Error::new(io::ErrorKind::Other, e.to_string()))
+}
+
+impl From<Color> for CColor {
+    fn from(color: Color) -> Self {
+        match color {
+            Color::Reset => CColor::Reset,
+            Color::Black => CColor::Black,
+            Color::Red => CColor::DarkRed,
+            Color::Green => CColor::DarkGreen,
+            Color::Yellow => CColor::DarkYellow,
+            Color::Blue => CColor::DarkBlue,
+            Color::Magenta => CColor::DarkMagenta,
+            Color::Cyan => CColor::DarkCyan,
+            Color::Gray => CColor::Grey,
+            Color::DarkGray => CColor::DarkGrey,
+            Color::LightRed => CColor::Red,
+            Color::LightGreen => CColor::Green,
+            Color::LightBlue => CColor::Blue,
+            Color::LightYellow => CColor::Yellow,
+            Color::LightMagenta => CColor::Magenta,
+            Color::LightCyan => CColor::Cyan,
+            Color::White => CColor::White,
+            Color::Indexed(i) => CColor::AnsiValue(i),
+            Color::Rgb(r, g, b) => CColor::Rgb { r, g, b },
+        }
+    }
+}
+
+#[derive(Debug)]
+struct ModifierDiff {
+    pub from: Modifier,
+    pub to: Modifier,
+}
+
+impl ModifierDiff {
+    fn queue<W>(&self, mut w: W) -> io::Result<()>
+    where
+        W: io::Write,
+    {
+        //use crossterm::Attribute;
+        let removed = self.from - self.to;
+        if removed.contains(Modifier::REVERSED) {
+            map_error(queue!(w, SetAttribute(CAttribute::NoReverse)))?;
+        }
+        if removed.contains(Modifier::BOLD) {
+            map_error(queue!(w, SetAttribute(CAttribute::NormalIntensity)))?;
+            if self.to.contains(Modifier::DIM) {
+                map_error(queue!(w, SetAttribute(CAttribute::Dim)))?;
+            }
+        }
+        if removed.contains(Modifier::ITALIC) {
+            map_error(queue!(w, SetAttribute(CAttribute::NoItalic)))?;
+        }
+        if removed.contains(Modifier::UNDERLINED) {
+            map_error(queue!(w, SetAttribute(CAttribute::NoUnderline)))?;
+        }
+        if removed.contains(Modifier::DIM) {
+            map_error(queue!(w, SetAttribute(CAttribute::NormalIntensity)))?;
+        }
+        if removed.contains(Modifier::CROSSED_OUT) {
+            map_error(queue!(w, SetAttribute(CAttribute::NotCrossedOut)))?;
+        }
+        if removed.contains(Modifier::SLOW_BLINK) || removed.contains(Modifier::RAPID_BLINK) {
+            map_error(queue!(w, SetAttribute(CAttribute::NoBlink)))?;
+        }
+
+        let added = self.to - self.from;
+        if added.contains(Modifier::REVERSED) {
+            map_error(queue!(w, SetAttribute(CAttribute::Reverse)))?;
+        }
+        if added.contains(Modifier::BOLD) {
+            map_error(queue!(w, SetAttribute(CAttribute::Bold)))?;
+        }
+        if added.contains(Modifier::ITALIC) {
+            map_error(queue!(w, SetAttribute(CAttribute::Italic)))?;
+        }
+        if added.contains(Modifier::UNDERLINED) {
+            map_error(queue!(w, SetAttribute(CAttribute::Underlined)))?;
+        }
+        if added.contains(Modifier::DIM) {
+            map_error(queue!(w, SetAttribute(CAttribute::Dim)))?;
+        }
+        if added.contains(Modifier::CROSSED_OUT) {
+            map_error(queue!(w, SetAttribute(CAttribute::CrossedOut)))?;
+        }
+        if added.contains(Modifier::SLOW_BLINK) {
+            map_error(queue!(w, SetAttribute(CAttribute::SlowBlink)))?;
+        }
+        if added.contains(Modifier::RAPID_BLINK) {
+            map_error(queue!(w, SetAttribute(CAttribute::RapidBlink)))?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/ratatui/backend/mod.rs b/src/ratatui/backend/mod.rs
new file mode 100644
index 00000000..a360db18
--- /dev/null
+++ b/src/ratatui/backend/mod.rs
@@ -0,0 +1,58 @@
+use std::io;
+
+use crate::ratatui::buffer::Cell;
+use crate::ratatui::layout::Rect;
+
+#[cfg(feature = "termion")]
+mod termion;
+#[cfg(feature = "termion")]
+pub use self::termion::TermionBackend;
+
+mod crossterm;
+pub use self::crossterm::CrosstermBackend;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ClearType {
+    All,
+    AfterCursor,
+    BeforeCursor,
+    CurrentLine,
+    UntilNewLine,
+}
+
+pub trait Backend {
+    fn draw<'a, I>(&mut self, content: I) -> Result<(), io::Error>
+    where
+        I: Iterator<Item = (u16, u16, &'a Cell)>;
+
+    /// Insert `n` line breaks to the terminal screen
+    fn append_lines(&mut self, n: u16) -> io::Result<()> {
+        // to get around the unused warning
+        let _n = n;
+        Ok(())
+    }
+
+    fn hide_cursor(&mut self) -> Result<(), io::Error>;
+    fn show_cursor(&mut self) -> Result<(), io::Error>;
+    fn get_cursor(&mut self) -> Result<(u16, u16), io::Error>;
+    fn set_cursor(&mut self, x: u16, y: u16) -> Result<(), io::Error>;
+
+    /// Clears the whole terminal screen
+    fn clear(&mut self) -> Result<(), io::Error>;
+
+    /// Clears a specific region of the terminal specified by the [`ClearType`] parameter
+    fn clear_region(&mut self, clear_type: ClearType) -> Result<(), io::Error> {
+        match clear_type {
+            ClearType::All => self.clear(),
+            ClearType::AfterCursor
+            | ClearType::BeforeCursor
+            | ClearType::CurrentLine
+            | ClearType::UntilNewLine => Err(io::Error::new(
+                io::ErrorKind::Other,
+                format!("clear_type [{clear_type:?}] not supported with this backend"),
+            )),
+        }
+    }
+    fn size(&self) -> Result<Rect, io::Error>;
+    fn flush(&mut self) -> Result<(), io::Error>;
+}
diff --git a/src/ratatui/backend/termion.rs b/src/ratatui/backend/termion.rs
new file mode 100644
index 00000000..76def792
--- /dev/null
+++ b/src/ratatui/backend/termion.rs
@@ -0,0 +1,275 @@
+use crate::{
+    backend::{Backend, ClearType},
+    buffer::Cell,
+    layout::Rect,
+    style::{Color, Modifier},
+};
+use std::{
+    fmt,
+    io::{self, Write},
+};
+
+pub struct TermionBackend<W>
+where
+    W: Write,
+{
+    stdout: W,
+}
+
+impl<W> TermionBackend<W>
+where
+    W: Write,
+{
+    pub fn new(stdout: W) -> TermionBackend<W> {
+        TermionBackend { stdout }
+    }
+}
+
+impl<W> Write for TermionBackend<W>
+where
+    W: Write,
+{
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.stdout.write(buf)
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.stdout.flush()
+    }
+}
+
+impl<W> Backend for TermionBackend<W>
+where
+    W: Write,
+{
+    fn clear(&mut self) -> io::Result<()> {
+        self.clear_region(ClearType::All)
+    }
+
+    fn clear_region(&mut self, clear_type: ClearType) -> io::Result<()> {
+        match clear_type {
+            ClearType::All => write!(self.stdout, "{}", termion::clear::All)?,
+            ClearType::AfterCursor => write!(self.stdout, "{}", termion::clear::AfterCursor)?,
+            ClearType::BeforeCursor => write!(self.stdout, "{}", termion::clear::BeforeCursor)?,
+            ClearType::CurrentLine => write!(self.stdout, "{}", termion::clear::CurrentLine)?,
+            ClearType::UntilNewLine => write!(self.stdout, "{}", termion::clear::UntilNewline)?,
+        };
+        self.stdout.flush()
+    }
+
+    fn append_lines(&mut self, n: u16) -> io::Result<()> {
+        for _ in 0..n {
+            writeln!(self.stdout)?;
+        }
+        self.stdout.flush()
+    }
+
+    /// Hides cursor
+    fn hide_cursor(&mut self) -> io::Result<()> {
+        write!(self.stdout, "{}", termion::cursor::Hide)?;
+        self.stdout.flush()
+    }
+
+    /// Shows cursor
+    fn show_cursor(&mut self) -> io::Result<()> {
+        write!(self.stdout, "{}", termion::cursor::Show)?;
+        self.stdout.flush()
+    }
+
+    /// Gets cursor position (0-based index)
+    fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        termion::cursor::DetectCursorPos::cursor_pos(&mut self.stdout).map(|(x, y)| (x - 1, y - 1))
+    }
+
+    /// Sets cursor position (0-based index)
+    fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        write!(self.stdout, "{}", termion::cursor::Goto(x + 1, y + 1))?;
+        self.stdout.flush()
+    }
+
+    fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
+    where
+        I: Iterator<Item = (u16, u16, &'a Cell)>,
+    {
+        use std::fmt::Write;
+
+        let mut string = String::with_capacity(content.size_hint().0 * 3);
+        let mut fg = Color::Reset;
+        let mut bg = Color::Reset;
+        let mut modifier = Modifier::empty();
+        let mut last_pos: Option<(u16, u16)> = None;
+        for (x, y, cell) in content {
+            // Move the cursor if the previous location was not (x - 1, y)
+            if !matches!(last_pos, Some(p) if x == p.0 + 1 && y == p.1) {
+                write!(string, "{}", termion::cursor::Goto(x + 1, y + 1)).unwrap();
+            }
+            last_pos = Some((x, y));
+            if cell.modifier != modifier {
+                write!(
+                    string,
+                    "{}",
+                    ModifierDiff {
+                        from: modifier,
+                        to: cell.modifier
+                    }
+                )
+                .unwrap();
+                modifier = cell.modifier;
+            }
+            if cell.fg != fg {
+                write!(string, "{}", Fg(cell.fg)).unwrap();
+                fg = cell.fg;
+            }
+            if cell.bg != bg {
+                write!(string, "{}", Bg(cell.bg)).unwrap();
+                bg = cell.bg;
+            }
+            string.push_str(&cell.symbol);
+        }
+        write!(
+            self.stdout,
+            "{}{}{}{}",
+            string,
+            Fg(Color::Reset),
+            Bg(Color::Reset),
+            termion::style::Reset,
+        )
+    }
+
+    /// Return the size of the terminal
+    fn size(&self) -> io::Result<Rect> {
+        let terminal = termion::terminal_size()?;
+        Ok(Rect::new(0, 0, terminal.0, terminal.1))
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        self.stdout.flush()
+    }
+}
+
+struct Fg(Color);
+
+struct Bg(Color);
+
+struct ModifierDiff {
+    from: Modifier,
+    to: Modifier,
+}
+
+impl fmt::Display for Fg {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use termion::color::Color as TermionColor;
+        match self.0 {
+            Color::Reset => termion::color::Reset.write_fg(f),
+            Color::Black => termion::color::Black.write_fg(f),
+            Color::Red => termion::color::Red.write_fg(f),
+            Color::Green => termion::color::Green.write_fg(f),
+            Color::Yellow => termion::color::Yellow.write_fg(f),
+            Color::Blue => termion::color::Blue.write_fg(f),
+            Color::Magenta => termion::color::Magenta.write_fg(f),
+            Color::Cyan => termion::color::Cyan.write_fg(f),
+            Color::Gray => termion::color::White.write_fg(f),
+            Color::DarkGray => termion::color::LightBlack.write_fg(f),
+            Color::LightRed => termion::color::LightRed.write_fg(f),
+            Color::LightGreen => termion::color::LightGreen.write_fg(f),
+            Color::LightBlue => termion::color::LightBlue.write_fg(f),
+            Color::LightYellow => termion::color::LightYellow.write_fg(f),
+            Color::LightMagenta => termion::color::LightMagenta.write_fg(f),
+            Color::LightCyan => termion::color::LightCyan.write_fg(f),
+            Color::White => termion::color::LightWhite.write_fg(f),
+            Color::Indexed(i) => termion::color::AnsiValue(i).write_fg(f),
+            Color::Rgb(r, g, b) => termion::color::Rgb(r, g, b).write_fg(f),
+        }
+    }
+}
+impl fmt::Display for Bg {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        use termion::color::Color as TermionColor;
+        match self.0 {
+            Color::Reset => termion::color::Reset.write_bg(f),
+            Color::Black => termion::color::Black.write_bg(f),
+            Color::Red => termion::color::Red.write_bg(f),
+            Color::Green => termion::color::Green.write_bg(f),
+            Color::Yellow => termion::color::Yellow.write_bg(f),
+            Color::Blue => termion::color::Blue.write_bg(f),
+            Color::Magenta => termion::color::Magenta.write_bg(f),
+            Color::Cyan => termion::color::Cyan.write_bg(f),
+            Color::Gray => termion::color::White.write_bg(f),
+            Color::DarkGray => termion::color::LightBlack.write_bg(f),
+            Color::LightRed => termion::color::LightRed.write_bg(f),
+            Color::LightGreen => termion::color::LightGreen.write_bg(f),
+            Color::LightBlue => termion::color::LightBlue.write_bg(f),
+            Color::LightYellow => termion::color::LightYellow.write_bg(f),
+            Color::LightMagenta => termion::color::LightMagenta.write_bg(f),
+            Color::LightCyan => termion::color::LightCyan.write_bg(f),
+            Color::White => termion::color::LightWhite.write_bg(f),
+            Color::Indexed(i) => termion::color::AnsiValue(i).write_bg(f),
+            Color::Rgb(r, g, b) => termion::color::Rgb(r, g, b).write_bg(f),
+        }
+    }
+}
+
+impl fmt::Display for ModifierDiff {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let remove = self.from - self.to;
+        if remove.contains(Modifier::REVERSED) {
+            write!(f, "{}", termion::style::NoInvert)?;
+        }
+        if remove.contains(Modifier::BOLD) {
+            // XXX: the termion NoBold flag actually enables double-underline on ECMA-48 compliant
+            // terminals, and NoFaint additionally disables bold... so we use this trick to get
+            // the right semantics.
+            write!(f, "{}", termion::style::NoFaint)?;
+
+            if self.to.contains(Modifier::DIM) {
+                write!(f, "{}", termion::style::Faint)?;
+            }
+        }
+        if remove.contains(Modifier::ITALIC) {
+            write!(f, "{}", termion::style::NoItalic)?;
+        }
+        if remove.contains(Modifier::UNDERLINED) {
+            write!(f, "{}", termion::style::NoUnderline)?;
+        }
+        if remove.contains(Modifier::DIM) {
+            write!(f, "{}", termion::style::NoFaint)?;
+
+            // XXX: the NoFaint flag additionally disables bold as well, so we need to re-enable it
+            // here if we want it.
+            if self.to.contains(Modifier::BOLD) {
+                write!(f, "{}", termion::style::Bold)?;
+            }
+        }
+        if remove.contains(Modifier::CROSSED_OUT) {
+            write!(f, "{}", termion::style::NoCrossedOut)?;
+        }
+        if remove.contains(Modifier::SLOW_BLINK) || remove.contains(Modifier::RAPID_BLINK) {
+            write!(f, "{}", termion::style::NoBlink)?;
+        }
+
+        let add = self.to - self.from;
+        if add.contains(Modifier::REVERSED) {
+            write!(f, "{}", termion::style::Invert)?;
+        }
+        if add.contains(Modifier::BOLD) {
+            write!(f, "{}", termion::style::Bold)?;
+        }
+        if add.contains(Modifier::ITALIC) {
+            write!(f, "{}", termion::style::Italic)?;
+        }
+        if add.contains(Modifier::UNDERLINED) {
+            write!(f, "{}", termion::style::Underline)?;
+        }
+        if add.contains(Modifier::DIM) {
+            write!(f, "{}", termion::style::Faint)?;
+        }
+        if add.contains(Modifier::CROSSED_OUT) {
+            write!(f, "{}", termion::style::CrossedOut)?;
+        }
+        if add.contains(Modifier::SLOW_BLINK) || add.contains(Modifier::RAPID_BLINK) {
+            write!(f, "{}", termion::style::Blink)?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/ratatui/buffer.rs b/src/ratatui/buffer.rs
new file mode 100644
index 00000000..b2a988b7
--- /dev/null
+++ b/src/ratatui/buffer.rs
@@ -0,0 +1,736 @@
+use crate::ratatui::{
+    layout::Rect,
+    style::{Color, Modifier, Style},
+    text::{Span, Spans},
+};
+use std::cmp::min;
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;
+
+/// A buffer cell
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Cell {
+    pub symbol: String,
+    pub fg: Color,
+    pub bg: Color,
+    pub modifier: Modifier,
+}
+
+impl Cell {
+    pub fn set_symbol(&mut self, symbol: &str) -> &mut Cell {
+        self.symbol.clear();
+        self.symbol.push_str(symbol);
+        self
+    }
+
+    pub fn set_char(&mut self, ch: char) -> &mut Cell {
+        self.symbol.clear();
+        self.symbol.push(ch);
+        self
+    }
+
+    pub fn set_fg(&mut self, color: Color) -> &mut Cell {
+        self.fg = color;
+        self
+    }
+
+    pub fn set_bg(&mut self, color: Color) -> &mut Cell {
+        self.bg = color;
+        self
+    }
+
+    pub fn set_style(&mut self, style: Style) -> &mut Cell {
+        if let Some(c) = style.fg {
+            self.fg = c;
+        }
+        if let Some(c) = style.bg {
+            self.bg = c;
+        }
+        self.modifier.insert(style.add_modifier);
+        self.modifier.remove(style.sub_modifier);
+        self
+    }
+
+    pub fn style(&self) -> Style {
+        Style::default()
+            .fg(self.fg)
+            .bg(self.bg)
+            .add_modifier(self.modifier)
+    }
+
+    pub fn reset(&mut self) {
+        self.symbol.clear();
+        self.symbol.push(' ');
+        self.fg = Color::Reset;
+        self.bg = Color::Reset;
+        self.modifier = Modifier::empty();
+    }
+}
+
+impl Default for Cell {
+    fn default() -> Cell {
+        Cell {
+            symbol: " ".into(),
+            fg: Color::Reset,
+            bg: Color::Reset,
+            modifier: Modifier::empty(),
+        }
+    }
+}
+
+/// A buffer that maps to the desired content of the terminal after the draw call
+///
+/// No widget in the library interacts directly with the terminal. Instead each of them is required
+/// to draw their state to an intermediate buffer. It is basically a grid where each cell contains
+/// a grapheme, a foreground color and a background color. This grid will then be used to output
+/// the appropriate escape sequences and characters to draw the UI as the user has defined it.
+///
+/// # Examples:
+///
+/// ```
+/// use ratatui::buffer::{Buffer, Cell};
+/// use ratatui::layout::Rect;
+/// use ratatui::style::{Color, Style, Modifier};
+///
+/// let mut buf = Buffer::empty(Rect{x: 0, y: 0, width: 10, height: 5});
+/// buf.get_mut(0, 2).set_symbol("x");
+/// assert_eq!(buf.get(0, 2).symbol, "x");
+/// buf.set_string(3, 0, "string", Style::default().fg(Color::Red).bg(Color::White));
+/// assert_eq!(buf.get(5, 0), &Cell{
+///     symbol: String::from("r"),
+///     fg: Color::Red,
+///     bg: Color::White,
+///     modifier: Modifier::empty()
+/// });
+/// buf.get_mut(5, 0).set_char('x');
+/// assert_eq!(buf.get(5, 0).symbol, "x");
+/// ```
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct Buffer {
+    /// The area represented by this buffer
+    pub area: Rect,
+    /// The content of the buffer. The length of this Vec should always be equal to area.width *
+    /// area.height
+    pub content: Vec<Cell>,
+}
+
+impl Buffer {
+    /// Returns a Buffer with all cells set to the default one
+    pub fn empty(area: Rect) -> Buffer {
+        let cell: Cell = Default::default();
+        Buffer::filled(area, &cell)
+    }
+
+    /// Returns a Buffer with all cells initialized with the attributes of the given Cell
+    pub fn filled(area: Rect, cell: &Cell) -> Buffer {
+        let size = area.area() as usize;
+        let mut content = Vec::with_capacity(size);
+        for _ in 0..size {
+            content.push(cell.clone());
+        }
+        Buffer { area, content }
+    }
+
+    /// Returns a Buffer containing the given lines
+    pub fn with_lines<S>(lines: Vec<S>) -> Buffer
+    where
+        S: AsRef<str>,
+    {
+        let height = lines.len() as u16;
+        let width = lines
+            .iter()
+            .map(|i| i.as_ref().width() as u16)
+            .max()
+            .unwrap_or_default();
+        let mut buffer = Buffer::empty(Rect {
+            x: 0,
+            y: 0,
+            width,
+            height,
+        });
+        for (y, line) in lines.iter().enumerate() {
+            buffer.set_string(0, y as u16, line, Style::default());
+        }
+        buffer
+    }
+
+    /// Returns the content of the buffer as a slice
+    pub fn content(&self) -> &[Cell] {
+        &self.content
+    }
+
+    /// Returns the area covered by this buffer
+    pub fn area(&self) -> &Rect {
+        &self.area
+    }
+
+    /// Returns a reference to Cell at the given coordinates
+    pub fn get(&self, x: u16, y: u16) -> &Cell {
+        let i = self.index_of(x, y);
+        &self.content[i]
+    }
+
+    /// Returns a mutable reference to Cell at the given coordinates
+    pub fn get_mut(&mut self, x: u16, y: u16) -> &mut Cell {
+        let i = self.index_of(x, y);
+        &mut self.content[i]
+    }
+
+    /// Returns the index in the `Vec<Cell>` for the given global (x, y) coordinates.
+    ///
+    /// Global coordinates are offset by the Buffer's area offset (`x`/`y`).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use ratatui::buffer::Buffer;
+    /// # use ratatui::layout::Rect;
+    /// let rect = Rect::new(200, 100, 10, 10);
+    /// let buffer = Buffer::empty(rect);
+    /// // Global coordinates to the top corner of this buffer's area
+    /// assert_eq!(buffer.index_of(200, 100), 0);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics when given an coordinate that is outside of this Buffer's area.
+    ///
+    /// ```should_panic
+    /// # use ratatui::buffer::Buffer;
+    /// # use ratatui::layout::Rect;
+    /// let rect = Rect::new(200, 100, 10, 10);
+    /// let buffer = Buffer::empty(rect);
+    /// // Top coordinate is outside of the buffer in global coordinate space, as the Buffer's area
+    /// // starts at (200, 100).
+    /// buffer.index_of(0, 0); // Panics
+    /// ```
+    pub fn index_of(&self, x: u16, y: u16) -> usize {
+        debug_assert!(
+            x >= self.area.left()
+                && x < self.area.right()
+                && y >= self.area.top()
+                && y < self.area.bottom(),
+            "Trying to access position outside the buffer: x={}, y={}, area={:?}",
+            x,
+            y,
+            self.area
+        );
+        ((y - self.area.y) * self.area.width + (x - self.area.x)) as usize
+    }
+
+    /// Returns the (global) coordinates of a cell given its index
+    ///
+    /// Global coordinates are offset by the Buffer's area offset (`x`/`y`).
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use ratatui::buffer::Buffer;
+    /// # use ratatui::layout::Rect;
+    /// let rect = Rect::new(200, 100, 10, 10);
+    /// let buffer = Buffer::empty(rect);
+    /// assert_eq!(buffer.pos_of(0), (200, 100));
+    /// assert_eq!(buffer.pos_of(14), (204, 101));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics when given an index that is outside the Buffer's content.
+    ///
+    /// ```should_panic
+    /// # use ratatui::buffer::Buffer;
+    /// # use ratatui::layout::Rect;
+    /// let rect = Rect::new(0, 0, 10, 10); // 100 cells in total
+    /// let buffer = Buffer::empty(rect);
+    /// // Index 100 is the 101th cell, which lies outside of the area of this Buffer.
+    /// buffer.pos_of(100); // Panics
+    /// ```
+    pub fn pos_of(&self, i: usize) -> (u16, u16) {
+        debug_assert!(
+            i < self.content.len(),
+            "Trying to get the coords of a cell outside the buffer: i={} len={}",
+            i,
+            self.content.len()
+        );
+        (
+            self.area.x + i as u16 % self.area.width,
+            self.area.y + i as u16 / self.area.width,
+        )
+    }
+
+    /// Print a string, starting at the position (x, y)
+    pub fn set_string<S>(&mut self, x: u16, y: u16, string: S, style: Style)
+    where
+        S: AsRef<str>,
+    {
+        self.set_stringn(x, y, string, usize::MAX, style);
+    }
+
+    /// Print at most the first n characters of a string if enough space is available
+    /// until the end of the line
+    pub fn set_stringn<S>(
+        &mut self,
+        x: u16,
+        y: u16,
+        string: S,
+        width: usize,
+        style: Style,
+    ) -> (u16, u16)
+    where
+        S: AsRef<str>,
+    {
+        let mut index = self.index_of(x, y);
+        let mut x_offset = x as usize;
+        let graphemes = UnicodeSegmentation::graphemes(string.as_ref(), true);
+        let max_offset = min(self.area.right() as usize, width.saturating_add(x as usize));
+        for s in graphemes {
+            let width = s.width();
+            if width == 0 {
+                continue;
+            }
+            // `x_offset + width > max_offset` could be integer overflow on 32-bit machines if we
+            // change dimensions to usize or u32 and someone resizes the terminal to 1x2^32.
+            if width > max_offset.saturating_sub(x_offset) {
+                break;
+            }
+
+            self.content[index].set_symbol(s);
+            self.content[index].set_style(style);
+            // Reset following cells if multi-width (they would be hidden by the grapheme),
+            for i in index + 1..index + width {
+                self.content[i].reset();
+            }
+            index += width;
+            x_offset += width;
+        }
+        (x_offset as u16, y)
+    }
+
+    pub fn set_spans(&mut self, x: u16, y: u16, spans: &Spans<'_>, width: u16) -> (u16, u16) {
+        let mut remaining_width = width;
+        let mut x = x;
+        for span in &spans.0 {
+            if remaining_width == 0 {
+                break;
+            }
+            let pos = self.set_stringn(
+                x,
+                y,
+                span.content.as_ref(),
+                remaining_width as usize,
+                span.style,
+            );
+            let w = pos.0.saturating_sub(x);
+            x = pos.0;
+            remaining_width = remaining_width.saturating_sub(w);
+        }
+        (x, y)
+    }
+
+    pub fn set_span(&mut self, x: u16, y: u16, span: &Span<'_>, width: u16) -> (u16, u16) {
+        self.set_stringn(x, y, span.content.as_ref(), width as usize, span.style)
+    }
+
+    #[deprecated(
+        since = "0.10.0",
+        note = "You should use styling capabilities of `Buffer::set_style`"
+    )]
+    pub fn set_background(&mut self, area: Rect, color: Color) {
+        for y in area.top()..area.bottom() {
+            for x in area.left()..area.right() {
+                self.get_mut(x, y).set_bg(color);
+            }
+        }
+    }
+
+    pub fn set_style(&mut self, area: Rect, style: Style) {
+        for y in area.top()..area.bottom() {
+            for x in area.left()..area.right() {
+                self.get_mut(x, y).set_style(style);
+            }
+        }
+    }
+
+    /// Resize the buffer so that the mapped area matches the given area and that the buffer
+    /// length is equal to area.width * area.height
+    pub fn resize(&mut self, area: Rect) {
+        let length = area.area() as usize;
+        if self.content.len() > length {
+            self.content.truncate(length);
+        } else {
+            self.content.resize(length, Default::default());
+        }
+        self.area = area;
+    }
+
+    /// Reset all cells in the buffer
+    pub fn reset(&mut self) {
+        for c in &mut self.content {
+            c.reset();
+        }
+    }
+
+    /// Merge an other buffer into this one
+    pub fn merge(&mut self, other: &Buffer) {
+        let area = self.area.union(other.area);
+        let cell: Cell = Default::default();
+        self.content.resize(area.area() as usize, cell.clone());
+
+        // Move original content to the appropriate space
+        let size = self.area.area() as usize;
+        for i in (0..size).rev() {
+            let (x, y) = self.pos_of(i);
+            // New index in content
+            let k = ((y - area.y) * area.width + x - area.x) as usize;
+            if i != k {
+                self.content[k] = self.content[i].clone();
+                self.content[i] = cell.clone();
+            }
+        }
+
+        // Push content of the other buffer into this one (may erase previous
+        // data)
+        let size = other.area.area() as usize;
+        for i in 0..size {
+            let (x, y) = other.pos_of(i);
+            // New index in content
+            let k = ((y - area.y) * area.width + x - area.x) as usize;
+            self.content[k] = other.content[i].clone();
+        }
+        self.area = area;
+    }
+
+    /// Builds a minimal sequence of coordinates and Cells necessary to update the UI from
+    /// self to other.
+    ///
+    /// We're assuming that buffers are well-formed, that is no double-width cell is followed by
+    /// a non-blank cell.
+    ///
+    /// # Multi-width characters handling:
+    ///
+    /// ```text
+    /// (Index:) `01`
+    /// Prev:    `コ`
+    /// Next:    `aa`
+    /// Updates: `0: a, 1: a'
+    /// ```
+    ///
+    /// ```text
+    /// (Index:) `01`
+    /// Prev:    `a `
+    /// Next:    `コ`
+    /// Updates: `0: コ` (double width symbol at index 0 - skip index 1)
+    /// ```
+    ///
+    /// ```text
+    /// (Index:) `012`
+    /// Prev:    `aaa`
+    /// Next:    `aコ`
+    /// Updates: `0: a, 1: コ` (double width symbol at index 1 - skip index 2)
+    /// ```
+    pub fn diff<'a>(&self, other: &'a Buffer) -> Vec<(u16, u16, &'a Cell)> {
+        let previous_buffer = &self.content;
+        let next_buffer = &other.content;
+
+        let mut updates: Vec<(u16, u16, &Cell)> = vec![];
+        // Cells invalidated by drawing/replacing preceding multi-width characters:
+        let mut invalidated: usize = 0;
+        // Cells from the current buffer to skip due to preceding multi-width characters taking their
+        // place (the skipped cells should be blank anyway):
+        let mut to_skip: usize = 0;
+        for (i, (current, previous)) in next_buffer.iter().zip(previous_buffer.iter()).enumerate() {
+            if (current != previous || invalidated > 0) && to_skip == 0 {
+                let (x, y) = self.pos_of(i);
+                updates.push((x, y, &next_buffer[i]));
+            }
+
+            to_skip = current.symbol.width().saturating_sub(1);
+
+            let affected_width = std::cmp::max(current.symbol.width(), previous.symbol.width());
+            invalidated = std::cmp::max(affected_width, invalidated).saturating_sub(1);
+        }
+        updates
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn cell(s: &str) -> Cell {
+        let mut cell = Cell::default();
+        cell.set_symbol(s);
+        cell
+    }
+
+    #[test]
+    fn it_translates_to_and_from_coordinates() {
+        let rect = Rect::new(200, 100, 50, 80);
+        let buf = Buffer::empty(rect);
+
+        // First cell is at the upper left corner.
+        assert_eq!(buf.pos_of(0), (200, 100));
+        assert_eq!(buf.index_of(200, 100), 0);
+
+        // Last cell is in the lower right.
+        assert_eq!(buf.pos_of(buf.content.len() - 1), (249, 179));
+        assert_eq!(buf.index_of(249, 179), buf.content.len() - 1);
+    }
+
+    #[test]
+    #[ignore]
+    #[should_panic(expected = "outside the buffer")]
+    fn pos_of_panics_on_out_of_bounds() {
+        let rect = Rect::new(0, 0, 10, 10);
+        let buf = Buffer::empty(rect);
+
+        // There are a total of 100 cells; zero-indexed means that 100 would be the 101st cell.
+        buf.pos_of(100);
+    }
+
+    #[test]
+    #[ignore]
+    #[should_panic(expected = "outside the buffer")]
+    fn index_of_panics_on_out_of_bounds() {
+        let rect = Rect::new(0, 0, 10, 10);
+        let buf = Buffer::empty(rect);
+
+        // width is 10; zero-indexed means that 10 would be the 11th cell.
+        buf.index_of(10, 0);
+    }
+
+    #[test]
+    fn buffer_set_string() {
+        let area = Rect::new(0, 0, 5, 1);
+        let mut buffer = Buffer::empty(area);
+
+        // Zero-width
+        buffer.set_stringn(0, 0, "aaa", 0, Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["     "]));
+
+        buffer.set_string(0, 0, "aaa", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["aaa  "]));
+
+        // Width limit:
+        buffer.set_stringn(0, 0, "bbbbbbbbbbbbbb", 4, Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["bbbb "]));
+
+        buffer.set_string(0, 0, "12345", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["12345"]));
+
+        // Width truncation:
+        buffer.set_string(0, 0, "123456", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["12345"]));
+    }
+
+    #[test]
+    fn buffer_set_string_zero_width() {
+        let area = Rect::new(0, 0, 1, 1);
+        let mut buffer = Buffer::empty(area);
+
+        // Leading grapheme with zero width
+        let s = "\u{1}a";
+        buffer.set_stringn(0, 0, s, 1, Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["a"]));
+
+        // Trailing grapheme with zero with
+        let s = "a\u{1}";
+        buffer.set_stringn(0, 0, s, 1, Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["a"]));
+    }
+
+    #[test]
+    fn buffer_set_string_double_width() {
+        let area = Rect::new(0, 0, 5, 1);
+        let mut buffer = Buffer::empty(area);
+        buffer.set_string(0, 0, "コン", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["コン "]));
+
+        // Only 1 space left.
+        buffer.set_string(0, 0, "コンピ", Style::default());
+        assert_eq!(buffer, Buffer::with_lines(vec!["コン "]));
+    }
+
+    #[test]
+    fn buffer_with_lines() {
+        let buffer =
+            Buffer::with_lines(vec!["┌────────┐", "│コンピュ│", "│ーa 上で│", "└────────┘"]);
+        assert_eq!(buffer.area.x, 0);
+        assert_eq!(buffer.area.y, 0);
+        assert_eq!(buffer.area.width, 10);
+        assert_eq!(buffer.area.height, 4);
+    }
+
+    #[test]
+    fn buffer_diffing_empty_empty() {
+        let area = Rect::new(0, 0, 40, 40);
+        let prev = Buffer::empty(area);
+        let next = Buffer::empty(area);
+        let diff = prev.diff(&next);
+        assert_eq!(diff, vec![]);
+    }
+
+    #[test]
+    fn buffer_diffing_empty_filled() {
+        let area = Rect::new(0, 0, 40, 40);
+        let prev = Buffer::empty(area);
+        let next = Buffer::filled(area, Cell::default().set_symbol("a"));
+        let diff = prev.diff(&next);
+        assert_eq!(diff.len(), 40 * 40);
+    }
+
+    #[test]
+    fn buffer_diffing_filled_filled() {
+        let area = Rect::new(0, 0, 40, 40);
+        let prev = Buffer::filled(area, Cell::default().set_symbol("a"));
+        let next = Buffer::filled(area, Cell::default().set_symbol("a"));
+        let diff = prev.diff(&next);
+        assert_eq!(diff, vec![]);
+    }
+
+    #[test]
+    fn buffer_diffing_single_width() {
+        let prev = Buffer::with_lines(vec![
+            "          ",
+            "┌Title─┐  ",
+            "│      │  ",
+            "│      │  ",
+            "└──────┘  ",
+        ]);
+        let next = Buffer::with_lines(vec![
+            "          ",
+            "┌TITLE─┐  ",
+            "│      │  ",
+            "│      │  ",
+            "└──────┘  ",
+        ]);
+        let diff = prev.diff(&next);
+        assert_eq!(
+            diff,
+            vec![
+                (2, 1, &cell("I")),
+                (3, 1, &cell("T")),
+                (4, 1, &cell("L")),
+                (5, 1, &cell("E")),
+            ]
+        );
+    }
+
+    #[test]
+    #[rustfmt::skip]
+    fn buffer_diffing_multi_width() {
+        let prev = Buffer::with_lines(vec![
+            "┌Title─┐  ",
+            "└──────┘  ",
+        ]);
+        let next = Buffer::with_lines(vec![
+            "┌称号──┐  ",
+            "└──────┘  ",
+        ]);
+        let diff = prev.diff(&next);
+        assert_eq!(
+            diff,
+            vec![
+                (1, 0, &cell("称")),
+                // Skipped "i"
+                (3, 0, &cell("号")),
+                // Skipped "l"
+                (5, 0, &cell("─")),
+            ]
+        );
+    }
+
+    #[test]
+    fn buffer_diffing_multi_width_offset() {
+        let prev = Buffer::with_lines(vec!["┌称号──┐"]);
+        let next = Buffer::with_lines(vec!["┌─称号─┐"]);
+
+        let diff = prev.diff(&next);
+        assert_eq!(
+            diff,
+            vec![(1, 0, &cell("─")), (2, 0, &cell("称")), (4, 0, &cell("号")),]
+        );
+    }
+
+    #[test]
+    fn buffer_merge() {
+        let mut one = Buffer::filled(
+            Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("1"),
+        );
+        let two = Buffer::filled(
+            Rect {
+                x: 0,
+                y: 2,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("2"),
+        );
+        one.merge(&two);
+        assert_eq!(one, Buffer::with_lines(vec!["11", "11", "22", "22"]));
+    }
+
+    #[test]
+    fn buffer_merge2() {
+        let mut one = Buffer::filled(
+            Rect {
+                x: 2,
+                y: 2,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("1"),
+        );
+        let two = Buffer::filled(
+            Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("2"),
+        );
+        one.merge(&two);
+        assert_eq!(
+            one,
+            Buffer::with_lines(vec!["22  ", "22  ", "  11", "  11"])
+        );
+    }
+
+    #[test]
+    fn buffer_merge3() {
+        let mut one = Buffer::filled(
+            Rect {
+                x: 3,
+                y: 3,
+                width: 2,
+                height: 2,
+            },
+            Cell::default().set_symbol("1"),
+        );
+        let two = Buffer::filled(
+            Rect {
+                x: 1,
+                y: 1,
+                width: 3,
+                height: 4,
+            },
+            Cell::default().set_symbol("2"),
+        );
+        one.merge(&two);
+        let mut merged = Buffer::with_lines(vec!["222 ", "222 ", "2221", "2221"]);
+        merged.area = Rect {
+            x: 1,
+            y: 1,
+            width: 4,
+            height: 4,
+        };
+        assert_eq!(one, merged);
+    }
+}
diff --git a/src/ratatui/layout.rs b/src/ratatui/layout.rs
new file mode 100644
index 00000000..f5b14e35
--- /dev/null
+++ b/src/ratatui/layout.rs
@@ -0,0 +1,560 @@
+use std::cell::RefCell;
+use std::cmp::{max, min};
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use cassowary::strength::{MEDIUM, REQUIRED, WEAK};
+use cassowary::WeightedRelation::*;
+use cassowary::{Constraint as CassowaryConstraint, Expression, Solver, Variable};
+
+#[derive(Debug, Hash, Clone, Copy, PartialEq, Eq)]
+pub enum Corner {
+    TopLeft,
+    TopRight,
+    BottomRight,
+    BottomLeft,
+}
+
+#[derive(Debug, Hash, Clone, PartialEq, Eq)]
+pub enum Direction {
+    Horizontal,
+    Vertical,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Constraint {
+    // TODO: enforce range 0 - 100
+    Percentage(u16),
+    Ratio(u32, u32),
+    Length(u16),
+    Max(u16),
+    Min(u16),
+}
+
+impl Constraint {
+    pub fn apply(&self, length: u16) -> u16 {
+        match *self {
+            Constraint::Percentage(p) => length * p / 100,
+            Constraint::Ratio(num, den) => {
+                let r = num * u32::from(length) / den;
+                r as u16
+            }
+            Constraint::Length(l) => length.min(l),
+            Constraint::Max(m) => length.min(m),
+            Constraint::Min(m) => length.max(m),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Margin {
+    pub vertical: u16,
+    pub horizontal: u16,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Alignment {
+    Left,
+    Center,
+    Right,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Layout {
+    direction: Direction,
+    margin: Margin,
+    constraints: Vec<Constraint>,
+    /// Whether the last chunk of the computed layout should be expanded to fill the available
+    /// space.
+    expand_to_fill: bool,
+}
+
+type Cache = HashMap<(Rect, Layout), Rc<[Rect]>>;
+thread_local! {
+    static LAYOUT_CACHE: RefCell<Cache> = RefCell::new(HashMap::new());
+}
+
+impl Default for Layout {
+    fn default() -> Layout {
+        Layout {
+            direction: Direction::Vertical,
+            margin: Margin {
+                horizontal: 0,
+                vertical: 0,
+            },
+            constraints: Vec::new(),
+            expand_to_fill: true,
+        }
+    }
+}
+
+impl Layout {
+    pub fn constraints<C>(mut self, constraints: C) -> Layout
+    where
+        C: Into<Vec<Constraint>>,
+    {
+        self.constraints = constraints.into();
+        self
+    }
+
+    pub fn margin(mut self, margin: u16) -> Layout {
+        self.margin = Margin {
+            horizontal: margin,
+            vertical: margin,
+        };
+        self
+    }
+
+    pub fn horizontal_margin(mut self, horizontal: u16) -> Layout {
+        self.margin.horizontal = horizontal;
+        self
+    }
+
+    pub fn vertical_margin(mut self, vertical: u16) -> Layout {
+        self.margin.vertical = vertical;
+        self
+    }
+
+    pub fn direction(mut self, direction: Direction) -> Layout {
+        self.direction = direction;
+        self
+    }
+
+    pub(crate) fn expand_to_fill(mut self, expand_to_fill: bool) -> Layout {
+        self.expand_to_fill = expand_to_fill;
+        self
+    }
+
+    /// Wrapper function around the cassowary-rs solver to be able to split a given
+    /// area into smaller ones based on the preferred widths or heights and the direction.
+    ///
+    /// # Examples
+    /// ```
+    /// # use ratatui::layout::{Rect, Constraint, Direction, Layout};
+    /// let chunks = Layout::default()
+    ///     .direction(Direction::Vertical)
+    ///     .constraints([Constraint::Length(5), Constraint::Min(0)].as_ref())
+    ///     .split(Rect {
+    ///         x: 2,
+    ///         y: 2,
+    ///         width: 10,
+    ///         height: 10,
+    ///     });
+    /// assert_eq!(
+    ///     chunks[..],
+    ///     [
+    ///         Rect {
+    ///             x: 2,
+    ///             y: 2,
+    ///             width: 10,
+    ///             height: 5
+    ///         },
+    ///         Rect {
+    ///             x: 2,
+    ///             y: 7,
+    ///             width: 10,
+    ///             height: 5
+    ///         }
+    ///     ]
+    /// );
+    ///
+    /// let chunks = Layout::default()
+    ///     .direction(Direction::Horizontal)
+    ///     .constraints([Constraint::Ratio(1, 3), Constraint::Ratio(2, 3)].as_ref())
+    ///     .split(Rect {
+    ///         x: 0,
+    ///         y: 0,
+    ///         width: 9,
+    ///         height: 2,
+    ///     });
+    /// assert_eq!(
+    ///     chunks[..],
+    ///     [
+    ///         Rect {
+    ///             x: 0,
+    ///             y: 0,
+    ///             width: 3,
+    ///             height: 2
+    ///         },
+    ///         Rect {
+    ///             x: 3,
+    ///             y: 0,
+    ///             width: 6,
+    ///             height: 2
+    ///         }
+    ///     ]
+    /// );
+    /// ```
+    pub fn split(&self, area: Rect) -> Rc<[Rect]> {
+        // TODO: Maybe use a fixed size cache ?
+        LAYOUT_CACHE.with(|c| {
+            c.borrow_mut()
+                .entry((area, self.clone()))
+                .or_insert_with(|| split(area, self))
+                .clone()
+        })
+    }
+}
+
+fn split(area: Rect, layout: &Layout) -> Rc<[Rect]> {
+    let mut solver = Solver::new();
+    let mut vars: HashMap<Variable, (usize, usize)> = HashMap::new();
+    let elements = layout
+        .constraints
+        .iter()
+        .map(|_| Element::new())
+        .collect::<Vec<Element>>();
+    let mut res = layout
+        .constraints
+        .iter()
+        .map(|_| Rect::default())
+        .collect::<Rc<[Rect]>>();
+
+    let mut results = Rc::get_mut(&mut res).expect("newly created Rc should have no shared refs");
+
+    let dest_area = area.inner(&layout.margin);
+    for (i, e) in elements.iter().enumerate() {
+        vars.insert(e.x, (i, 0));
+        vars.insert(e.y, (i, 1));
+        vars.insert(e.width, (i, 2));
+        vars.insert(e.height, (i, 3));
+    }
+    let mut ccs: Vec<CassowaryConstraint> =
+        Vec::with_capacity(elements.len() * 4 + layout.constraints.len() * 6);
+    for elt in &elements {
+        ccs.push(elt.width | GE(REQUIRED) | 0f64);
+        ccs.push(elt.height | GE(REQUIRED) | 0f64);
+        ccs.push(elt.left() | GE(REQUIRED) | f64::from(dest_area.left()));
+        ccs.push(elt.top() | GE(REQUIRED) | f64::from(dest_area.top()));
+        ccs.push(elt.right() | LE(REQUIRED) | f64::from(dest_area.right()));
+        ccs.push(elt.bottom() | LE(REQUIRED) | f64::from(dest_area.bottom()));
+    }
+    if let Some(first) = elements.first() {
+        ccs.push(match layout.direction {
+            Direction::Horizontal => first.left() | EQ(REQUIRED) | f64::from(dest_area.left()),
+            Direction::Vertical => first.top() | EQ(REQUIRED) | f64::from(dest_area.top()),
+        });
+    }
+    if layout.expand_to_fill {
+        if let Some(last) = elements.last() {
+            ccs.push(match layout.direction {
+                Direction::Horizontal => last.right() | EQ(REQUIRED) | f64::from(dest_area.right()),
+                Direction::Vertical => last.bottom() | EQ(REQUIRED) | f64::from(dest_area.bottom()),
+            });
+        }
+    }
+    match layout.direction {
+        Direction::Horizontal => {
+            for pair in elements.windows(2) {
+                ccs.push((pair[0].x + pair[0].width) | EQ(REQUIRED) | pair[1].x);
+            }
+            for (i, size) in layout.constraints.iter().enumerate() {
+                ccs.push(elements[i].y | EQ(REQUIRED) | f64::from(dest_area.y));
+                ccs.push(elements[i].height | EQ(REQUIRED) | f64::from(dest_area.height));
+                ccs.push(match *size {
+                    Constraint::Length(v) => elements[i].width | EQ(MEDIUM) | f64::from(v),
+                    Constraint::Percentage(v) => {
+                        elements[i].width | EQ(MEDIUM) | (f64::from(v * dest_area.width) / 100.0)
+                    }
+                    Constraint::Ratio(n, d) => {
+                        elements[i].width
+                            | EQ(MEDIUM)
+                            | (f64::from(dest_area.width) * f64::from(n) / f64::from(d))
+                    }
+                    Constraint::Min(v) => elements[i].width | GE(MEDIUM) | f64::from(v),
+                    Constraint::Max(v) => elements[i].width | LE(MEDIUM) | f64::from(v),
+                });
+
+                match *size {
+                    Constraint::Min(v) => {
+                        ccs.push(elements[i].width | EQ(WEAK) | f64::from(v));
+                    }
+                    Constraint::Max(v) => {
+                        ccs.push(elements[i].width | EQ(WEAK) | f64::from(v));
+                    }
+                    _ => {}
+                }
+            }
+        }
+        Direction::Vertical => {
+            for pair in elements.windows(2) {
+                ccs.push((pair[0].y + pair[0].height) | EQ(REQUIRED) | pair[1].y);
+            }
+            for (i, size) in layout.constraints.iter().enumerate() {
+                ccs.push(elements[i].x | EQ(REQUIRED) | f64::from(dest_area.x));
+                ccs.push(elements[i].width | EQ(REQUIRED) | f64::from(dest_area.width));
+                ccs.push(match *size {
+                    Constraint::Length(v) => elements[i].height | EQ(MEDIUM) | f64::from(v),
+                    Constraint::Percentage(v) => {
+                        elements[i].height | EQ(MEDIUM) | (f64::from(v * dest_area.height) / 100.0)
+                    }
+                    Constraint::Ratio(n, d) => {
+                        elements[i].height
+                            | EQ(MEDIUM)
+                            | (f64::from(dest_area.height) * f64::from(n) / f64::from(d))
+                    }
+                    Constraint::Min(v) => elements[i].height | GE(MEDIUM) | f64::from(v),
+                    Constraint::Max(v) => elements[i].height | LE(MEDIUM) | f64::from(v),
+                });
+
+                match *size {
+                    Constraint::Min(v) => {
+                        ccs.push(elements[i].height | EQ(WEAK) | f64::from(v));
+                    }
+                    Constraint::Max(v) => {
+                        ccs.push(elements[i].height | EQ(WEAK) | f64::from(v));
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+    solver.add_constraints(&ccs).unwrap();
+    for &(var, value) in solver.fetch_changes() {
+        let (index, attr) = vars[&var];
+        let value = if value.is_sign_negative() {
+            0
+        } else {
+            value as u16
+        };
+        match attr {
+            0 => {
+                results[index].x = value;
+            }
+            1 => {
+                results[index].y = value;
+            }
+            2 => {
+                results[index].width = value;
+            }
+            3 => {
+                results[index].height = value;
+            }
+            _ => {}
+        }
+    }
+
+    if layout.expand_to_fill {
+        // Fix imprecision by extending the last item a bit if necessary
+        if let Some(last) = results.last_mut() {
+            match layout.direction {
+                Direction::Vertical => {
+                    last.height = dest_area.bottom() - last.y;
+                }
+                Direction::Horizontal => {
+                    last.width = dest_area.right() - last.x;
+                }
+            }
+        }
+    }
+    res
+}
+
+/// A container used by the solver inside split
+struct Element {
+    x: Variable,
+    y: Variable,
+    width: Variable,
+    height: Variable,
+}
+
+impl Element {
+    fn new() -> Element {
+        Element {
+            x: Variable::new(),
+            y: Variable::new(),
+            width: Variable::new(),
+            height: Variable::new(),
+        }
+    }
+
+    fn left(&self) -> Variable {
+        self.x
+    }
+
+    fn top(&self) -> Variable {
+        self.y
+    }
+
+    fn right(&self) -> Expression {
+        self.x + self.width
+    }
+
+    fn bottom(&self) -> Expression {
+        self.y + self.height
+    }
+}
+
+/// A simple rectangle used in the computation of the layout and to give widgets a hint about the
+/// area they are supposed to render to.
+#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, Default)]
+pub struct Rect {
+    pub x: u16,
+    pub y: u16,
+    pub width: u16,
+    pub height: u16,
+}
+
+impl Rect {
+    /// Creates a new rect, with width and height limited to keep the area under max u16.
+    /// If clipped, aspect ratio will be preserved.
+    pub fn new(x: u16, y: u16, width: u16, height: u16) -> Rect {
+        let max_area = u16::max_value();
+        let (clipped_width, clipped_height) =
+            if u32::from(width) * u32::from(height) > u32::from(max_area) {
+                let aspect_ratio = f64::from(width) / f64::from(height);
+                let max_area_f = f64::from(max_area);
+                let height_f = (max_area_f / aspect_ratio).sqrt();
+                let width_f = height_f * aspect_ratio;
+                (width_f as u16, height_f as u16)
+            } else {
+                (width, height)
+            };
+        Rect {
+            x,
+            y,
+            width: clipped_width,
+            height: clipped_height,
+        }
+    }
+
+    pub fn area(self) -> u16 {
+        self.width * self.height
+    }
+
+    pub fn left(self) -> u16 {
+        self.x
+    }
+
+    pub fn right(self) -> u16 {
+        self.x.saturating_add(self.width)
+    }
+
+    pub fn top(self) -> u16 {
+        self.y
+    }
+
+    pub fn bottom(self) -> u16 {
+        self.y.saturating_add(self.height)
+    }
+
+    pub fn inner(self, margin: &Margin) -> Rect {
+        if self.width < 2 * margin.horizontal || self.height < 2 * margin.vertical {
+            Rect::default()
+        } else {
+            Rect {
+                x: self.x + margin.horizontal,
+                y: self.y + margin.vertical,
+                width: self.width - 2 * margin.horizontal,
+                height: self.height - 2 * margin.vertical,
+            }
+        }
+    }
+
+    pub fn union(self, other: Rect) -> Rect {
+        let x1 = min(self.x, other.x);
+        let y1 = min(self.y, other.y);
+        let x2 = max(self.x + self.width, other.x + other.width);
+        let y2 = max(self.y + self.height, other.y + other.height);
+        Rect {
+            x: x1,
+            y: y1,
+            width: x2 - x1,
+            height: y2 - y1,
+        }
+    }
+
+    pub fn intersection(self, other: Rect) -> Rect {
+        let x1 = max(self.x, other.x);
+        let y1 = max(self.y, other.y);
+        let x2 = min(self.x + self.width, other.x + other.width);
+        let y2 = min(self.y + self.height, other.y + other.height);
+        Rect {
+            x: x1,
+            y: y1,
+            width: x2 - x1,
+            height: y2 - y1,
+        }
+    }
+
+    pub fn intersects(self, other: Rect) -> bool {
+        self.x < other.x + other.width
+            && self.x + self.width > other.x
+            && self.y < other.y + other.height
+            && self.y + self.height > other.y
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_vertical_split_by_height() {
+        let target = Rect {
+            x: 2,
+            y: 2,
+            width: 10,
+            height: 10,
+        };
+
+        let chunks = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints(
+                [
+                    Constraint::Percentage(10),
+                    Constraint::Max(5),
+                    Constraint::Min(1),
+                ]
+                .as_ref(),
+            )
+            .split(target);
+
+        assert_eq!(target.height, chunks.iter().map(|r| r.height).sum::<u16>());
+        chunks.windows(2).for_each(|w| assert!(w[0].y <= w[1].y));
+    }
+
+    #[test]
+    fn test_rect_size_truncation() {
+        for width in 256u16..300u16 {
+            for height in 256u16..300u16 {
+                let rect = Rect::new(0, 0, width, height);
+                rect.area(); // Should not panic.
+                assert!(rect.width < width || rect.height < height);
+                // The target dimensions are rounded down so the math will not be too precise
+                // but let's make sure the ratios don't diverge crazily.
+                assert!(
+                    (f64::from(rect.width) / f64::from(rect.height)
+                        - f64::from(width) / f64::from(height))
+                    .abs()
+                        < 1.0
+                )
+            }
+        }
+
+        // One dimension below 255, one above. Area above max u16.
+        let width = 900;
+        let height = 100;
+        let rect = Rect::new(0, 0, width, height);
+        assert_ne!(rect.width, 900);
+        assert_ne!(rect.height, 100);
+        assert!(rect.width < width || rect.height < height);
+    }
+
+    #[test]
+    fn test_rect_size_preservation() {
+        for width in 0..256u16 {
+            for height in 0..256u16 {
+                let rect = Rect::new(0, 0, width, height);
+                rect.area(); // Should not panic.
+                assert_eq!(rect.width, width);
+                assert_eq!(rect.height, height);
+            }
+        }
+
+        // One dimension below 255, one above. Area below max u16.
+        let rect = Rect::new(0, 0, 300, 100);
+        assert_eq!(rect.width, 300);
+        assert_eq!(rect.height, 100);
+    }
+}
diff --git a/src/ratatui/mod.rs b/src/ratatui/mod.rs
new file mode 100644
index 00000000..d7926b96
--- /dev/null
+++ b/src/ratatui/mod.rs
@@ -0,0 +1,177 @@
+#![allow(clippy::all)]
+#![allow(warnings)]
+
+//! [ratatui](https://github.com/tui-rs-revival/ratatui) is a library used to build rich
+//! terminal users interfaces and dashboards.
+//!
+//! ![](https://raw.githubusercontent.com/tui-rs-revival/ratatui/master/assets/demo.gif)
+//!
+//! # Get started
+//!
+//! ## Adding `ratatui` as a dependency
+//!
+//! Add the following to your `Cargo.toml`:
+//! ```toml
+//! [dependencies]
+//! crossterm = "0.26"
+//! ratatui = "0.20"
+//! ```
+//!
+//! The crate is using the `crossterm` backend by default that works on most platforms. But if for
+//! example you want to use the `termion` backend instead. This can be done by changing your
+//! dependencies specification to the following:
+//!
+//! ```toml
+//! [dependencies]
+//! termion = "1.5"
+//! ratatui = { version = "0.20", default-features = false, features = ['termion'] }
+//!
+//! ```
+//!
+//! The same logic applies for all other available backends.
+//!
+//! ## Creating a `Terminal`
+//!
+//! Every application using `ratatui` should start by instantiating a `Terminal`. It is a light
+//! abstraction over available backends that provides basic functionalities such as clearing the
+//! screen, hiding the cursor, etc.
+//!
+//! ```rust,no_run
+//! use std::io;
+//! use ratatui::{backend::CrosstermBackend, Terminal};
+//!
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout();
+//!     let backend = CrosstermBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! If you had previously chosen `termion` as a backend, the terminal can be created in a similar
+//! way:
+//!
+//! ```rust,ignore
+//! use std::io;
+//! use ratatui::{backend::TermionBackend, Terminal};
+//! use termion::raw::IntoRawMode;
+//!
+//! fn main() -> Result<(), io::Error> {
+//!     let stdout = io::stdout().into_raw_mode()?;
+//!     let backend = TermionBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!     Ok(())
+//! }
+//! ```
+//!
+//! You may also refer to the examples to find out how to create a `Terminal` for each available
+//! backend.
+//!
+//! ## Building a User Interface (UI)
+//!
+//! Every component of your interface will be implementing the `Widget` trait. The library comes
+//! with a predefined set of widgets that should meet most of your use cases. You are also free to
+//! implement your own.
+//!
+//! Each widget follows a builder pattern API providing a default configuration along with methods
+//! to customize them. The widget is then rendered using [`Frame::render_widget`] which takes
+//! your widget instance and an area to draw to.
+//!
+//! The following example renders a block of the size of the terminal:
+//!
+//! ```rust,no_run
+//! use std::{io, thread, time::Duration};
+//! use ratatui::{
+//!     backend::CrosstermBackend,
+//!     widgets::{Widget, Block, Borders},
+//!     layout::{Layout, Constraint, Direction},
+//!     Terminal
+//! };
+//! use crossterm::{
+//!     event::{self, DisableMouseCapture, EnableMouseCapture, Event, KeyCode},
+//!     execute,
+//!     terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
+//! };
+//!
+//! fn main() -> Result<(), io::Error> {
+//!     // setup terminal
+//!     enable_raw_mode()?;
+//!     let mut stdout = io::stdout();
+//!     execute!(stdout, EnterAlternateScreen, EnableMouseCapture)?;
+//!     let backend = CrosstermBackend::new(stdout);
+//!     let mut terminal = Terminal::new(backend)?;
+//!
+//!     terminal.draw(|f| {
+//!         let size = f.size();
+//!         let block = Block::default()
+//!             .title("Block")
+//!             .borders(Borders::ALL);
+//!         f.render_widget(block, size);
+//!     })?;
+//!
+//!     thread::sleep(Duration::from_millis(5000));
+//!
+//!     // restore terminal
+//!     disable_raw_mode()?;
+//!     execute!(
+//!         terminal.backend_mut(),
+//!         LeaveAlternateScreen,
+//!         DisableMouseCapture
+//!     )?;
+//!     terminal.show_cursor()?;
+//!
+//!     Ok(())
+//! }
+//! ```
+//!
+//! ## Layout
+//!
+//! The library comes with a basic yet useful layout management object called `Layout`. As you may
+//! see below and in the examples, the library makes heavy use of the builder pattern to provide
+//! full customization. And `Layout` is no exception:
+//!
+//! ```rust,no_run
+//! use ratatui::{
+//!     backend::Backend,
+//!     layout::{Constraint, Direction, Layout},
+//!     widgets::{Block, Borders},
+//!     Frame,
+//! };
+//! fn ui<B: Backend>(f: &mut Frame<B>) {
+//!    let chunks = Layout::default()
+//!         .direction(Direction::Vertical)
+//!         .margin(1)
+//!         .constraints(
+//!             [
+//!                 Constraint::Percentage(10),
+//!                 Constraint::Percentage(80),
+//!                 Constraint::Percentage(10)
+//!             ].as_ref()
+//!         )
+//!         .split(f.size());
+//!     let block = Block::default()
+//!          .title("Block")
+//!          .borders(Borders::ALL);
+//!     f.render_widget(block, chunks[0]);
+//!     let block = Block::default()
+//!          .title("Block 2")
+//!          .borders(Borders::ALL);
+//!     f.render_widget(block, chunks[1]);
+//! }
+//! ```
+//!
+//! This let you describe responsive terminal UI by nesting layouts. You should note that by
+//! default the computed layout tries to fill the available space completely. So if for any reason
+//! you might need a blank space somewhere, try to pass an additional constraint and don't use the
+//! corresponding area.
+
+pub mod backend;
+pub mod buffer;
+pub mod layout;
+pub mod style;
+pub mod symbols;
+pub mod terminal;
+pub mod text;
+pub mod widgets;
+
+pub use self::terminal::{Frame, Terminal, TerminalOptions, Viewport};
diff --git a/src/ratatui/style.rs b/src/ratatui/style.rs
new file mode 100644
index 00000000..4d74f6fc
--- /dev/null
+++ b/src/ratatui/style.rs
@@ -0,0 +1,310 @@
+//! `style` contains the primitives used to control how your user interface will look.
+
+use bitflags::bitflags;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum Color {
+    Reset,
+    Black,
+    Red,
+    Green,
+    Yellow,
+    Blue,
+    Magenta,
+    Cyan,
+    Gray,
+    DarkGray,
+    LightRed,
+    LightGreen,
+    LightYellow,
+    LightBlue,
+    LightMagenta,
+    LightCyan,
+    White,
+    Rgb(u8, u8, u8),
+    Indexed(u8),
+}
+
+bitflags! {
+    /// Modifier changes the way a piece of text is displayed.
+    ///
+    /// They are bitflags so they can easily be composed.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::style::Modifier;
+    ///
+    /// let m = Modifier::BOLD | Modifier::ITALIC;
+    /// ```
+    #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+    pub struct Modifier: u16 {
+        const BOLD              = 0b0000_0000_0001;
+        const DIM               = 0b0000_0000_0010;
+        const ITALIC            = 0b0000_0000_0100;
+        const UNDERLINED        = 0b0000_0000_1000;
+        const SLOW_BLINK        = 0b0000_0001_0000;
+        const RAPID_BLINK       = 0b0000_0010_0000;
+        const REVERSED          = 0b0000_0100_0000;
+        const HIDDEN            = 0b0000_1000_0000;
+        const CROSSED_OUT       = 0b0001_0000_0000;
+    }
+}
+
+/// Style let you control the main characteristics of the displayed elements.
+///
+/// ```rust
+/// # use ratatui::style::{Color, Modifier, Style};
+/// Style::default()
+///     .fg(Color::Black)
+///     .bg(Color::Green)
+///     .add_modifier(Modifier::ITALIC | Modifier::BOLD);
+/// ```
+///
+/// It represents an incremental change. If you apply the styles S1, S2, S3 to a cell of the
+/// terminal buffer, the style of this cell will be the result of the merge of S1, S2 and S3, not
+/// just S3.
+///
+/// ```rust
+/// # use ratatui::style::{Color, Modifier, Style};
+/// # use ratatui::buffer::Buffer;
+/// # use ratatui::layout::Rect;
+/// let styles = [
+///     Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
+///     Style::default().bg(Color::Red),
+///     Style::default().fg(Color::Yellow).remove_modifier(Modifier::ITALIC),
+/// ];
+/// let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
+/// for style in &styles {
+///   buffer.get_mut(0, 0).set_style(*style);
+/// }
+/// assert_eq!(
+///     Style {
+///         fg: Some(Color::Yellow),
+///         bg: Some(Color::Red),
+///         add_modifier: Modifier::BOLD,
+///         sub_modifier: Modifier::empty(),
+///     },
+///     buffer.get(0, 0).style(),
+/// );
+/// ```
+///
+/// The default implementation returns a `Style` that does not modify anything. If you wish to
+/// reset all properties until that point use [`Style::reset`].
+///
+/// ```
+/// # use ratatui::style::{Color, Modifier, Style};
+/// # use ratatui::buffer::Buffer;
+/// # use ratatui::layout::Rect;
+/// let styles = [
+///     Style::default().fg(Color::Blue).add_modifier(Modifier::BOLD | Modifier::ITALIC),
+///     Style::reset().fg(Color::Yellow),
+/// ];
+/// let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
+/// for style in &styles {
+///   buffer.get_mut(0, 0).set_style(*style);
+/// }
+/// assert_eq!(
+///     Style {
+///         fg: Some(Color::Yellow),
+///         bg: Some(Color::Reset),
+///         add_modifier: Modifier::empty(),
+///         sub_modifier: Modifier::empty(),
+///     },
+///     buffer.get(0, 0).style(),
+/// );
+/// ```
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Style {
+    pub fg: Option<Color>,
+    pub bg: Option<Color>,
+    pub add_modifier: Modifier,
+    pub sub_modifier: Modifier,
+}
+
+impl Default for Style {
+    fn default() -> Style {
+        Style {
+            fg: None,
+            bg: None,
+            add_modifier: Modifier::empty(),
+            sub_modifier: Modifier::empty(),
+        }
+    }
+}
+
+impl Style {
+    /// Returns a `Style` resetting all properties.
+    pub fn reset() -> Style {
+        Style {
+            fg: Some(Color::Reset),
+            bg: Some(Color::Reset),
+            add_modifier: Modifier::empty(),
+            sub_modifier: Modifier::all(),
+        }
+    }
+
+    /// Changes the foreground color.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::style::{Color, Style};
+    /// let style = Style::default().fg(Color::Blue);
+    /// let diff = Style::default().fg(Color::Red);
+    /// assert_eq!(style.patch(diff), Style::default().fg(Color::Red));
+    /// ```
+    pub fn fg(mut self, color: Color) -> Style {
+        self.fg = Some(color);
+        self
+    }
+
+    /// Changes the background color.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::style::{Color, Style};
+    /// let style = Style::default().bg(Color::Blue);
+    /// let diff = Style::default().bg(Color::Red);
+    /// assert_eq!(style.patch(diff), Style::default().bg(Color::Red));
+    /// ```
+    pub fn bg(mut self, color: Color) -> Style {
+        self.bg = Some(color);
+        self
+    }
+
+    /// Changes the text emphasis.
+    ///
+    /// When applied, it adds the given modifier to the `Style` modifiers.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::style::{Color, Modifier, Style};
+    /// let style = Style::default().add_modifier(Modifier::BOLD);
+    /// let diff = Style::default().add_modifier(Modifier::ITALIC);
+    /// let patched = style.patch(diff);
+    /// assert_eq!(patched.add_modifier, Modifier::BOLD | Modifier::ITALIC);
+    /// assert_eq!(patched.sub_modifier, Modifier::empty());
+    /// ```
+    pub fn add_modifier(mut self, modifier: Modifier) -> Style {
+        self.sub_modifier.remove(modifier);
+        self.add_modifier.insert(modifier);
+        self
+    }
+
+    /// Changes the text emphasis.
+    ///
+    /// When applied, it removes the given modifier from the `Style` modifiers.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::style::{Color, Modifier, Style};
+    /// let style = Style::default().add_modifier(Modifier::BOLD | Modifier::ITALIC);
+    /// let diff = Style::default().remove_modifier(Modifier::ITALIC);
+    /// let patched = style.patch(diff);
+    /// assert_eq!(patched.add_modifier, Modifier::BOLD);
+    /// assert_eq!(patched.sub_modifier, Modifier::ITALIC);
+    /// ```
+    pub fn remove_modifier(mut self, modifier: Modifier) -> Style {
+        self.add_modifier.remove(modifier);
+        self.sub_modifier.insert(modifier);
+        self
+    }
+
+    /// Results in a combined style that is equivalent to applying the two individual styles to
+    /// a style one after the other.
+    ///
+    /// ## Examples
+    /// ```
+    /// # use ratatui::style::{Color, Modifier, Style};
+    /// let style_1 = Style::default().fg(Color::Yellow);
+    /// let style_2 = Style::default().bg(Color::Red);
+    /// let combined = style_1.patch(style_2);
+    /// assert_eq!(
+    ///     Style::default().patch(style_1).patch(style_2),
+    ///     Style::default().patch(combined));
+    /// ```
+    pub fn patch(mut self, other: Style) -> Style {
+        self.fg = other.fg.or(self.fg);
+        self.bg = other.bg.or(self.bg);
+
+        self.add_modifier.remove(other.sub_modifier);
+        self.add_modifier.insert(other.add_modifier);
+        self.sub_modifier.remove(other.add_modifier);
+        self.sub_modifier.insert(other.sub_modifier);
+
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn styles() -> Vec<Style> {
+        vec![
+            Style::default(),
+            Style::default().fg(Color::Yellow),
+            Style::default().bg(Color::Yellow),
+            Style::default().add_modifier(Modifier::BOLD),
+            Style::default().remove_modifier(Modifier::BOLD),
+            Style::default().add_modifier(Modifier::ITALIC),
+            Style::default().remove_modifier(Modifier::ITALIC),
+            Style::default().add_modifier(Modifier::ITALIC | Modifier::BOLD),
+            Style::default().remove_modifier(Modifier::ITALIC | Modifier::BOLD),
+        ]
+    }
+
+    #[test]
+    fn combined_patch_gives_same_result_as_individual_patch() {
+        let styles = styles();
+        for &a in &styles {
+            for &b in &styles {
+                for &c in &styles {
+                    for &d in &styles {
+                        let combined = a.patch(b.patch(c.patch(d)));
+
+                        assert_eq!(
+                            Style::default().patch(a).patch(b).patch(c).patch(d),
+                            Style::default().patch(combined)
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn combine_individual_modifiers() {
+        use crate::ratatui::{buffer::Buffer, layout::Rect};
+
+        let mods = vec![
+            Modifier::BOLD,
+            Modifier::DIM,
+            Modifier::ITALIC,
+            Modifier::UNDERLINED,
+            Modifier::SLOW_BLINK,
+            Modifier::RAPID_BLINK,
+            Modifier::REVERSED,
+            Modifier::HIDDEN,
+            Modifier::CROSSED_OUT,
+        ];
+
+        let mut buffer = Buffer::empty(Rect::new(0, 0, 1, 1));
+
+        for m in &mods {
+            buffer.get_mut(0, 0).set_style(Style::reset());
+            buffer
+                .get_mut(0, 0)
+                .set_style(Style::default().add_modifier(*m));
+            let style = buffer.get(0, 0).style();
+            assert!(style.add_modifier.contains(*m));
+            assert!(!style.sub_modifier.contains(*m));
+        }
+    }
+}
diff --git a/src/ratatui/symbols.rs b/src/ratatui/symbols.rs
new file mode 100644
index 00000000..040e77f6
--- /dev/null
+++ b/src/ratatui/symbols.rs
@@ -0,0 +1,233 @@
+pub mod block {
+    pub const FULL: &str = "█";
+    pub const SEVEN_EIGHTHS: &str = "▉";
+    pub const THREE_QUARTERS: &str = "▊";
+    pub const FIVE_EIGHTHS: &str = "▋";
+    pub const HALF: &str = "▌";
+    pub const THREE_EIGHTHS: &str = "▍";
+    pub const ONE_QUARTER: &str = "▎";
+    pub const ONE_EIGHTH: &str = "▏";
+
+    #[derive(Debug, Clone)]
+    pub struct Set {
+        pub full: &'static str,
+        pub seven_eighths: &'static str,
+        pub three_quarters: &'static str,
+        pub five_eighths: &'static str,
+        pub half: &'static str,
+        pub three_eighths: &'static str,
+        pub one_quarter: &'static str,
+        pub one_eighth: &'static str,
+        pub empty: &'static str,
+    }
+
+    pub const THREE_LEVELS: Set = Set {
+        full: FULL,
+        seven_eighths: FULL,
+        three_quarters: HALF,
+        five_eighths: HALF,
+        half: HALF,
+        three_eighths: HALF,
+        one_quarter: HALF,
+        one_eighth: " ",
+        empty: " ",
+    };
+
+    pub const NINE_LEVELS: Set = Set {
+        full: FULL,
+        seven_eighths: SEVEN_EIGHTHS,
+        three_quarters: THREE_QUARTERS,
+        five_eighths: FIVE_EIGHTHS,
+        half: HALF,
+        three_eighths: THREE_EIGHTHS,
+        one_quarter: ONE_QUARTER,
+        one_eighth: ONE_EIGHTH,
+        empty: " ",
+    };
+}
+
+pub mod bar {
+    pub const FULL: &str = "█";
+    pub const SEVEN_EIGHTHS: &str = "▇";
+    pub const THREE_QUARTERS: &str = "▆";
+    pub const FIVE_EIGHTHS: &str = "▅";
+    pub const HALF: &str = "▄";
+    pub const THREE_EIGHTHS: &str = "▃";
+    pub const ONE_QUARTER: &str = "▂";
+    pub const ONE_EIGHTH: &str = "▁";
+
+    #[derive(Debug, Clone)]
+    pub struct Set {
+        pub full: &'static str,
+        pub seven_eighths: &'static str,
+        pub three_quarters: &'static str,
+        pub five_eighths: &'static str,
+        pub half: &'static str,
+        pub three_eighths: &'static str,
+        pub one_quarter: &'static str,
+        pub one_eighth: &'static str,
+        pub empty: &'static str,
+    }
+
+    pub const THREE_LEVELS: Set = Set {
+        full: FULL,
+        seven_eighths: FULL,
+        three_quarters: HALF,
+        five_eighths: HALF,
+        half: HALF,
+        three_eighths: HALF,
+        one_quarter: HALF,
+        one_eighth: " ",
+        empty: " ",
+    };
+
+    pub const NINE_LEVELS: Set = Set {
+        full: FULL,
+        seven_eighths: SEVEN_EIGHTHS,
+        three_quarters: THREE_QUARTERS,
+        five_eighths: FIVE_EIGHTHS,
+        half: HALF,
+        three_eighths: THREE_EIGHTHS,
+        one_quarter: ONE_QUARTER,
+        one_eighth: ONE_EIGHTH,
+        empty: " ",
+    };
+}
+
+pub mod line {
+    pub const VERTICAL: &str = "│";
+    pub const DOUBLE_VERTICAL: &str = "║";
+    pub const THICK_VERTICAL: &str = "┃";
+
+    pub const HORIZONTAL: &str = "─";
+    pub const DOUBLE_HORIZONTAL: &str = "═";
+    pub const THICK_HORIZONTAL: &str = "━";
+
+    pub const TOP_RIGHT: &str = "┐";
+    pub const ROUNDED_TOP_RIGHT: &str = "╮";
+    pub const DOUBLE_TOP_RIGHT: &str = "╗";
+    pub const THICK_TOP_RIGHT: &str = "┓";
+
+    pub const TOP_LEFT: &str = "┌";
+    pub const ROUNDED_TOP_LEFT: &str = "╭";
+    pub const DOUBLE_TOP_LEFT: &str = "╔";
+    pub const THICK_TOP_LEFT: &str = "┏";
+
+    pub const BOTTOM_RIGHT: &str = "┘";
+    pub const ROUNDED_BOTTOM_RIGHT: &str = "╯";
+    pub const DOUBLE_BOTTOM_RIGHT: &str = "╝";
+    pub const THICK_BOTTOM_RIGHT: &str = "┛";
+
+    pub const BOTTOM_LEFT: &str = "└";
+    pub const ROUNDED_BOTTOM_LEFT: &str = "╰";
+    pub const DOUBLE_BOTTOM_LEFT: &str = "╚";
+    pub const THICK_BOTTOM_LEFT: &str = "┗";
+
+    pub const VERTICAL_LEFT: &str = "┤";
+    pub const DOUBLE_VERTICAL_LEFT: &str = "╣";
+    pub const THICK_VERTICAL_LEFT: &str = "┫";
+
+    pub const VERTICAL_RIGHT: &str = "├";
+    pub const DOUBLE_VERTICAL_RIGHT: &str = "╠";
+    pub const THICK_VERTICAL_RIGHT: &str = "┣";
+
+    pub const HORIZONTAL_DOWN: &str = "┬";
+    pub const DOUBLE_HORIZONTAL_DOWN: &str = "╦";
+    pub const THICK_HORIZONTAL_DOWN: &str = "┳";
+
+    pub const HORIZONTAL_UP: &str = "┴";
+    pub const DOUBLE_HORIZONTAL_UP: &str = "╩";
+    pub const THICK_HORIZONTAL_UP: &str = "┻";
+
+    pub const CROSS: &str = "┼";
+    pub const DOUBLE_CROSS: &str = "╬";
+    pub const THICK_CROSS: &str = "╋";
+
+    #[derive(Debug, Clone)]
+    pub struct Set {
+        pub vertical: &'static str,
+        pub horizontal: &'static str,
+        pub top_right: &'static str,
+        pub top_left: &'static str,
+        pub bottom_right: &'static str,
+        pub bottom_left: &'static str,
+        pub vertical_left: &'static str,
+        pub vertical_right: &'static str,
+        pub horizontal_down: &'static str,
+        pub horizontal_up: &'static str,
+        pub cross: &'static str,
+    }
+
+    pub const NORMAL: Set = Set {
+        vertical: VERTICAL,
+        horizontal: HORIZONTAL,
+        top_right: TOP_RIGHT,
+        top_left: TOP_LEFT,
+        bottom_right: BOTTOM_RIGHT,
+        bottom_left: BOTTOM_LEFT,
+        vertical_left: VERTICAL_LEFT,
+        vertical_right: VERTICAL_RIGHT,
+        horizontal_down: HORIZONTAL_DOWN,
+        horizontal_up: HORIZONTAL_UP,
+        cross: CROSS,
+    };
+
+    pub const ROUNDED: Set = Set {
+        top_right: ROUNDED_TOP_RIGHT,
+        top_left: ROUNDED_TOP_LEFT,
+        bottom_right: ROUNDED_BOTTOM_RIGHT,
+        bottom_left: ROUNDED_BOTTOM_LEFT,
+        ..NORMAL
+    };
+
+    pub const DOUBLE: Set = Set {
+        vertical: DOUBLE_VERTICAL,
+        horizontal: DOUBLE_HORIZONTAL,
+        top_right: DOUBLE_TOP_RIGHT,
+        top_left: DOUBLE_TOP_LEFT,
+        bottom_right: DOUBLE_BOTTOM_RIGHT,
+        bottom_left: DOUBLE_BOTTOM_LEFT,
+        vertical_left: DOUBLE_VERTICAL_LEFT,
+        vertical_right: DOUBLE_VERTICAL_RIGHT,
+        horizontal_down: DOUBLE_HORIZONTAL_DOWN,
+        horizontal_up: DOUBLE_HORIZONTAL_UP,
+        cross: DOUBLE_CROSS,
+    };
+
+    pub const THICK: Set = Set {
+        vertical: THICK_VERTICAL,
+        horizontal: THICK_HORIZONTAL,
+        top_right: THICK_TOP_RIGHT,
+        top_left: THICK_TOP_LEFT,
+        bottom_right: THICK_BOTTOM_RIGHT,
+        bottom_left: THICK_BOTTOM_LEFT,
+        vertical_left: THICK_VERTICAL_LEFT,
+        vertical_right: THICK_VERTICAL_RIGHT,
+        horizontal_down: THICK_HORIZONTAL_DOWN,
+        horizontal_up: THICK_HORIZONTAL_UP,
+        cross: THICK_CROSS,
+    };
+}
+
+pub const DOT: &str = "•";
+
+pub mod braille {
+    pub const BLANK: u16 = 0x2800;
+    pub const DOTS: [[u16; 2]; 4] = [
+        [0x0001, 0x0008],
+        [0x0002, 0x0010],
+        [0x0004, 0x0020],
+        [0x0040, 0x0080],
+    ];
+}
+
+/// Marker to use when plotting data points
+#[derive(Debug, Clone, Copy)]
+pub enum Marker {
+    /// One point per cell in shape of dot
+    Dot,
+    /// One point per cell in shape of a block
+    Block,
+    /// Up to 8 points per cell
+    Braille,
+}
diff --git a/src/ratatui/terminal.rs b/src/ratatui/terminal.rs
new file mode 100644
index 00000000..32accffa
--- /dev/null
+++ b/src/ratatui/terminal.rs
@@ -0,0 +1,487 @@
+use crate::ratatui::{
+    backend::{Backend, ClearType},
+    buffer::Buffer,
+    layout::Rect,
+    widgets::{StatefulWidget, Widget},
+};
+use std::io;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Viewport {
+    Fullscreen,
+    Inline(u16),
+    Fixed(Rect),
+}
+
+impl Viewport {
+    pub fn fixed(area: Rect) -> Viewport {
+        Self::Fixed(area)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+/// Options to pass to [`Terminal::with_options`]
+pub struct TerminalOptions {
+    /// Viewport used to draw to the terminal
+    pub viewport: Viewport,
+}
+
+/// Interface to the terminal backed by Termion
+#[derive(Debug)]
+pub struct Terminal<B>
+where
+    B: Backend,
+{
+    backend: B,
+    /// Holds the results of the current and previous draw calls. The two are compared at the end
+    /// of each draw pass to output the necessary updates to the terminal
+    buffers: [Buffer; 2],
+    /// Index of the current buffer in the previous array
+    current: usize,
+    /// Whether the cursor is currently hidden
+    hidden_cursor: bool,
+    /// Viewport
+    viewport: Viewport,
+    viewport_area: Rect,
+    /// Last known size of the terminal. Used to detect if the internal buffers have to be resized.
+    last_known_size: Rect,
+    /// Last known position of the cursor. Used to find the new area when the viewport is inlined
+    /// and the terminal resized.
+    last_known_cursor_pos: (u16, u16),
+}
+
+/// Represents a consistent terminal interface for rendering.
+pub struct Frame<'a, B: 'a>
+where
+    B: Backend,
+{
+    terminal: &'a mut Terminal<B>,
+
+    /// Where should the cursor be after drawing this frame?
+    ///
+    /// If `None`, the cursor is hidden and its position is controlled by the backend. If `Some((x,
+    /// y))`, the cursor is shown and placed at `(x, y)` after the call to `Terminal::draw()`.
+    cursor_position: Option<(u16, u16)>,
+}
+
+impl<'a, B> Frame<'a, B>
+where
+    B: Backend,
+{
+    /// Frame size, guaranteed not to change when rendering.
+    pub fn size(&self) -> Rect {
+        self.terminal.viewport_area
+    }
+
+    /// Render a [`Widget`] to the current buffer using [`Widget::render`].
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ratatui::Terminal;
+    /// # use ratatui::backend::TestBackend;
+    /// # use ratatui::layout::Rect;
+    /// # use ratatui::widgets::Block;
+    /// # let backend = TestBackend::new(5, 5);
+    /// # let mut terminal = Terminal::new(backend).unwrap();
+    /// let block = Block::default();
+    /// let area = Rect::new(0, 0, 5, 5);
+    /// let mut frame = terminal.get_frame();
+    /// frame.render_widget(block, area);
+    /// ```
+    pub fn render_widget<W>(&mut self, widget: W, area: Rect)
+    where
+        W: Widget,
+    {
+        widget.render(area, self.terminal.current_buffer_mut());
+    }
+
+    /// Render a [`StatefulWidget`] to the current buffer using [`StatefulWidget::render`].
+    ///
+    /// The last argument should be an instance of the [`StatefulWidget::State`] associated to the
+    /// given [`StatefulWidget`].
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ratatui::Terminal;
+    /// # use ratatui::backend::TestBackend;
+    /// # use ratatui::layout::Rect;
+    /// # use ratatui::widgets::{List, ListItem, ListState};
+    /// # let backend = TestBackend::new(5, 5);
+    /// # let mut terminal = Terminal::new(backend).unwrap();
+    /// let mut state = ListState::default();
+    /// state.select(Some(1));
+    /// let items = vec![
+    ///     ListItem::new("Item 1"),
+    ///     ListItem::new("Item 2"),
+    /// ];
+    /// let list = List::new(items);
+    /// let area = Rect::new(0, 0, 5, 5);
+    /// let mut frame = terminal.get_frame();
+    /// frame.render_stateful_widget(list, area, &mut state);
+    /// ```
+    pub fn render_stateful_widget<W>(&mut self, widget: W, area: Rect, state: &mut W::State)
+    where
+        W: StatefulWidget,
+    {
+        widget.render(area, self.terminal.current_buffer_mut(), state);
+    }
+
+    /// After drawing this frame, make the cursor visible and put it at the specified (x, y)
+    /// coordinates. If this method is not called, the cursor will be hidden.
+    ///
+    /// Note that this will interfere with calls to `Terminal::hide_cursor()`,
+    /// `Terminal::show_cursor()`, and `Terminal::set_cursor()`. Pick one of the APIs and stick
+    /// with it.
+    pub fn set_cursor(&mut self, x: u16, y: u16) {
+        self.cursor_position = Some((x, y));
+    }
+}
+
+/// CompletedFrame represents the state of the terminal after all changes performed in the last
+/// [`Terminal::draw`] call have been applied. Therefore, it is only valid until the next call to
+/// [`Terminal::draw`].
+pub struct CompletedFrame<'a> {
+    pub buffer: &'a Buffer,
+    pub area: Rect,
+}
+
+impl<B> Drop for Terminal<B>
+where
+    B: Backend,
+{
+    fn drop(&mut self) {
+        // Attempt to restore the cursor state
+        if self.hidden_cursor {
+            if let Err(err) = self.show_cursor() {
+                eprintln!("Failed to show the cursor: {}", err);
+            }
+        }
+    }
+}
+
+impl<B> Terminal<B>
+where
+    B: Backend,
+{
+    /// Wrapper around Terminal initialization. Each buffer is initialized with a blank string and
+    /// default colors for the foreground and the background
+    pub fn new(backend: B) -> io::Result<Terminal<B>> {
+        Terminal::with_options(
+            backend,
+            TerminalOptions {
+                viewport: Viewport::Fullscreen,
+            },
+        )
+    }
+
+    pub fn with_options(mut backend: B, options: TerminalOptions) -> io::Result<Terminal<B>> {
+        let size = match options.viewport {
+            Viewport::Fullscreen | Viewport::Inline(_) => backend.size()?,
+            Viewport::Fixed(area) => area,
+        };
+        let (viewport_area, cursor_pos) = match options.viewport {
+            Viewport::Fullscreen => (size, (0, 0)),
+            Viewport::Inline(height) => compute_inline_size(&mut backend, height, size, 0)?,
+            Viewport::Fixed(area) => (area, (area.left(), area.top())),
+        };
+        Ok(Terminal {
+            backend,
+            buffers: [Buffer::empty(viewport_area), Buffer::empty(viewport_area)],
+            current: 0,
+            hidden_cursor: false,
+            viewport: options.viewport,
+            viewport_area,
+            last_known_size: size,
+            last_known_cursor_pos: cursor_pos,
+        })
+    }
+
+    /// Get a Frame object which provides a consistent view into the terminal state for rendering.
+    pub fn get_frame(&mut self) -> Frame<B> {
+        Frame {
+            terminal: self,
+            cursor_position: None,
+        }
+    }
+
+    pub fn current_buffer_mut(&mut self) -> &mut Buffer {
+        &mut self.buffers[self.current]
+    }
+
+    pub fn backend(&self) -> &B {
+        &self.backend
+    }
+
+    pub fn backend_mut(&mut self) -> &mut B {
+        &mut self.backend
+    }
+
+    /// Obtains a difference between the previous and the current buffer and passes it to the
+    /// current backend for drawing.
+    pub fn flush(&mut self) -> io::Result<()> {
+        let previous_buffer = &self.buffers[1 - self.current];
+        let current_buffer = &self.buffers[self.current];
+        let updates = previous_buffer.diff(current_buffer);
+        if let Some((col, row, _)) = updates.last() {
+            self.last_known_cursor_pos = (*col, *row);
+        }
+        self.backend.draw(updates.into_iter())
+    }
+
+    /// Updates the Terminal so that internal buffers match the requested size. Requested size will
+    /// be saved so the size can remain consistent when rendering.
+    /// This leads to a full clear of the screen.
+    pub fn resize(&mut self, size: Rect) -> io::Result<()> {
+        let next_area = match self.viewport {
+            Viewport::Fullscreen => size,
+            Viewport::Inline(height) => {
+                let offset_in_previous_viewport = self
+                    .last_known_cursor_pos
+                    .1
+                    .saturating_sub(self.viewport_area.top());
+                compute_inline_size(&mut self.backend, height, size, offset_in_previous_viewport)?.0
+            }
+            Viewport::Fixed(area) => area,
+        };
+        self.set_viewport_area(next_area);
+        self.clear()?;
+
+        self.last_known_size = size;
+        Ok(())
+    }
+
+    fn set_viewport_area(&mut self, area: Rect) {
+        self.buffers[self.current].resize(area);
+        self.buffers[1 - self.current].resize(area);
+        self.viewport_area = area;
+    }
+
+    /// Queries the backend for size and resizes if it doesn't match the previous size.
+    pub fn autoresize(&mut self) -> io::Result<()> {
+        // fixed viewports do not get autoresized
+        if matches!(self.viewport, Viewport::Fullscreen | Viewport::Inline(_)) {
+            let size = self.size()?;
+            if size != self.last_known_size {
+                self.resize(size)?;
+            }
+        };
+        Ok(())
+    }
+
+    /// Synchronizes terminal size, calls the rendering closure, flushes the current internal state
+    /// and prepares for the next draw call.
+    pub fn draw<F>(&mut self, f: F) -> io::Result<CompletedFrame>
+    where
+        F: FnOnce(&mut Frame<B>),
+    {
+        // Autoresize - otherwise we get glitches if shrinking or potential desync between widgets
+        // and the terminal (if growing), which may OOB.
+        self.autoresize()?;
+
+        let mut frame = self.get_frame();
+        f(&mut frame);
+        // We can't change the cursor position right away because we have to flush the frame to
+        // stdout first. But we also can't keep the frame around, since it holds a &mut to
+        // Terminal. Thus, we're taking the important data out of the Frame and dropping it.
+        let cursor_position = frame.cursor_position;
+
+        // Draw to stdout
+        self.flush()?;
+
+        match cursor_position {
+            None => self.hide_cursor()?,
+            Some((x, y)) => {
+                self.show_cursor()?;
+                self.set_cursor(x, y)?;
+            }
+        }
+
+        // Swap buffers
+        self.buffers[1 - self.current].reset();
+        self.current = 1 - self.current;
+
+        // Flush
+        self.backend.flush()?;
+
+        Ok(CompletedFrame {
+            buffer: &self.buffers[1 - self.current],
+            area: self.last_known_size,
+        })
+    }
+
+    pub fn hide_cursor(&mut self) -> io::Result<()> {
+        self.backend.hide_cursor()?;
+        self.hidden_cursor = true;
+        Ok(())
+    }
+
+    pub fn show_cursor(&mut self) -> io::Result<()> {
+        self.backend.show_cursor()?;
+        self.hidden_cursor = false;
+        Ok(())
+    }
+
+    pub fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
+        self.backend.get_cursor()
+    }
+
+    pub fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
+        self.backend.set_cursor(x, y)?;
+        self.last_known_cursor_pos = (x, y);
+        Ok(())
+    }
+
+    /// Clear the terminal and force a full redraw on the next draw call.
+    pub fn clear(&mut self) -> io::Result<()> {
+        match self.viewport {
+            Viewport::Fullscreen => self.backend.clear_region(ClearType::All)?,
+            Viewport::Inline(_) => {
+                self.backend
+                    .set_cursor(self.viewport_area.left(), self.viewport_area.top())?;
+                self.backend.clear_region(ClearType::AfterCursor)?;
+            }
+            Viewport::Fixed(area) => {
+                for row in area.top()..area.bottom() {
+                    self.backend.set_cursor(0, row)?;
+                    self.backend.clear_region(ClearType::AfterCursor)?;
+                }
+            }
+        }
+        // Reset the back buffer to make sure the next update will redraw everything.
+        self.buffers[1 - self.current].reset();
+        Ok(())
+    }
+
+    /// Queries the real size of the backend.
+    pub fn size(&self) -> io::Result<Rect> {
+        self.backend.size()
+    }
+
+    /// Insert some content before the current inline viewport. This has no effect when the
+    /// viewport is fullscreen.
+    ///
+    /// This function scrolls down the current viewport by the given height. The newly freed space is
+    /// then made available to the `draw_fn` closure through a writable `Buffer`.
+    ///
+    /// Before:
+    /// ```ignore
+    /// +-------------------+
+    /// |                   |
+    /// |      viewport     |
+    /// |                   |
+    /// +-------------------+
+    /// ```
+    ///
+    /// After:
+    /// ```ignore
+    /// +-------------------+
+    /// |      buffer       |
+    /// +-------------------+
+    /// +-------------------+
+    /// |                   |
+    /// |      viewport     |
+    /// |                   |
+    /// +-------------------+
+    /// ```
+    ///
+    /// # Examples
+    ///
+    /// ## Insert a single line before the current viewport
+    ///
+    /// ```rust
+    /// # use ratatui::widgets::{Paragraph, Widget};
+    /// # use ratatui::text::{Spans, Span};
+    /// # use ratatui::style::{Color, Style};
+    /// # use ratatui::{Terminal};
+    /// # use ratatui::backend::TestBackend;
+    /// # let backend = TestBackend::new(10, 10);
+    /// # let mut terminal = Terminal::new(backend).unwrap();
+    /// terminal.insert_before(1, |buf| {
+    ///     Paragraph::new(Spans::from(vec![
+    ///         Span::raw("This line will be added "),
+    ///         Span::styled("before", Style::default().fg(Color::Blue)),
+    ///         Span::raw(" the current viewport")
+    ///     ])).render(buf.area, buf);
+    /// });
+    /// ```
+    pub fn insert_before<F>(&mut self, height: u16, draw_fn: F) -> io::Result<()>
+    where
+        F: FnOnce(&mut Buffer),
+    {
+        if !matches!(self.viewport, Viewport::Inline(_)) {
+            return Ok(());
+        }
+
+        self.clear()?;
+        let height = height.min(self.last_known_size.height);
+        self.backend.append_lines(height)?;
+        let missing_lines =
+            height.saturating_sub(self.last_known_size.bottom() - self.viewport_area.top());
+        let area = Rect {
+            x: self.viewport_area.left(),
+            y: self.viewport_area.top().saturating_sub(missing_lines),
+            width: self.viewport_area.width,
+            height,
+        };
+        let mut buffer = Buffer::empty(area);
+
+        draw_fn(&mut buffer);
+
+        let iter = buffer.content.iter().enumerate().map(|(i, c)| {
+            let (x, y) = buffer.pos_of(i);
+            (x, y, c)
+        });
+        self.backend.draw(iter)?;
+        self.backend.flush()?;
+
+        let remaining_lines = self.last_known_size.height - area.bottom();
+        let missing_lines = self.viewport_area.height.saturating_sub(remaining_lines);
+        self.backend.append_lines(self.viewport_area.height)?;
+
+        self.set_viewport_area(Rect {
+            x: area.left(),
+            y: area.bottom().saturating_sub(missing_lines),
+            width: area.width,
+            height: self.viewport_area.height,
+        });
+
+        Ok(())
+    }
+}
+
+fn compute_inline_size<B: Backend>(
+    backend: &mut B,
+    height: u16,
+    size: Rect,
+    offset_in_previous_viewport: u16,
+) -> io::Result<(Rect, (u16, u16))> {
+    let pos = backend.get_cursor()?;
+    let mut row = pos.1;
+
+    let max_height = size.height.min(height);
+
+    let lines_after_cursor = height
+        .saturating_sub(offset_in_previous_viewport)
+        .saturating_sub(1);
+
+    backend.append_lines(lines_after_cursor)?;
+
+    let available_lines = size.height.saturating_sub(row).saturating_sub(1);
+    let missing_lines = lines_after_cursor.saturating_sub(available_lines);
+    if missing_lines > 0 {
+        row = row.saturating_sub(missing_lines);
+    }
+    row = row.saturating_sub(offset_in_previous_viewport);
+
+    Ok((
+        Rect {
+            x: 0,
+            y: row,
+            width: size.width,
+            height: max_height,
+        },
+        pos,
+    ))
+}
diff --git a/src/ratatui/text.rs b/src/ratatui/text.rs
new file mode 100644
index 00000000..50e3d5cf
--- /dev/null
+++ b/src/ratatui/text.rs
@@ -0,0 +1,430 @@
+//! Primitives for styled text.
+//!
+//! A terminal UI is at its root a lot of strings. In order to make it accessible and stylish,
+//! those strings may be associated to a set of styles. `ratatui` has three ways to represent them:
+//! - A single line string where all graphemes have the same style is represented by a [`Span`].
+//! - A single line string where each grapheme may have its own style is represented by [`Spans`].
+//! - A multiple line string where each grapheme may have its own style is represented by a
+//! [`Text`].
+//!
+//! These types form a hierarchy: [`Spans`] is a collection of [`Span`] and each line of [`Text`]
+//! is a [`Spans`].
+//!
+//! Keep it mind that a lot of widgets will use those types to advertise what kind of string is
+//! supported for their properties. Moreover, `ratatui` provides convenient `From` implementations so
+//! that you can start by using simple `String` or `&str` and then promote them to the previous
+//! primitives when you need additional styling capabilities.
+//!
+//! For example, for the [`crate::widgets::Block`] widget, all the following calls are valid to set
+//! its `title` property (which is a [`Spans`] under the hood):
+//!
+//! ```rust
+//! # use ratatui::widgets::Block;
+//! # use ratatui::text::{Span, Spans};
+//! # use ratatui::style::{Color, Style};
+//! // A simple string with no styling.
+//! // Converted to Spans(vec![
+//! //   Span { content: Cow::Borrowed("My title"), style: Style { .. } }
+//! // ])
+//! let block = Block::default().title("My title");
+//!
+//! // A simple string with a unique style.
+//! // Converted to Spans(vec![
+//! //   Span { content: Cow::Borrowed("My title"), style: Style { fg: Some(Color::Yellow), .. }
+//! // ])
+//! let block = Block::default().title(
+//!     Span::styled("My title", Style::default().fg(Color::Yellow))
+//! );
+//!
+//! // A string with multiple styles.
+//! // Converted to Spans(vec![
+//! //   Span { content: Cow::Borrowed("My"), style: Style { fg: Some(Color::Yellow), .. } },
+//! //   Span { content: Cow::Borrowed(" title"), .. }
+//! // ])
+//! let block = Block::default().title(vec![
+//!     Span::styled("My", Style::default().fg(Color::Yellow)),
+//!     Span::raw(" title"),
+//! ]);
+//! ```
+use crate::ratatui::style::Style;
+use std::borrow::Cow;
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;
+
+/// A grapheme associated to a style.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct StyledGrapheme<'a> {
+    pub symbol: &'a str,
+    pub style: Style,
+}
+
+/// A string where all graphemes have the same style.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Span<'a> {
+    pub content: Cow<'a, str>,
+    pub style: Style,
+}
+
+impl<'a> Span<'a> {
+    /// Create a span with no style.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::text::Span;
+    /// Span::raw("My text");
+    /// Span::raw(String::from("My text"));
+    /// ```
+    pub fn raw<T>(content: T) -> Span<'a>
+    where
+        T: Into<Cow<'a, str>>,
+    {
+        Span {
+            content: content.into(),
+            style: Style::default(),
+        }
+    }
+
+    /// Create a span with a style.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ratatui::text::Span;
+    /// # use ratatui::style::{Color, Modifier, Style};
+    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
+    /// Span::styled("My text", style);
+    /// Span::styled(String::from("My text"), style);
+    /// ```
+    pub fn styled<T>(content: T, style: Style) -> Span<'a>
+    where
+        T: Into<Cow<'a, str>>,
+    {
+        Span {
+            content: content.into(),
+            style,
+        }
+    }
+
+    /// Returns the width of the content held by this span.
+    pub fn width(&self) -> usize {
+        self.content.width()
+    }
+
+    /// Returns an iterator over the graphemes held by this span.
+    ///
+    /// `base_style` is the [`Style`] that will be patched with each grapheme [`Style`] to get
+    /// the resulting [`Style`].
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::text::{Span, StyledGrapheme};
+    /// # use ratatui::style::{Color, Modifier, Style};
+    /// # use std::iter::Iterator;
+    /// let style = Style::default().fg(Color::Yellow);
+    /// let span = Span::styled("Text", style);
+    /// let style = Style::default().fg(Color::Green).bg(Color::Black);
+    /// let styled_graphemes = span.styled_graphemes(style);
+    /// assert_eq!(
+    ///     vec![
+    ///         StyledGrapheme {
+    ///             symbol: "T",
+    ///             style: Style {
+    ///                 fg: Some(Color::Yellow),
+    ///                 bg: Some(Color::Black),
+    ///                 add_modifier: Modifier::empty(),
+    ///                 sub_modifier: Modifier::empty(),
+    ///             },
+    ///         },
+    ///         StyledGrapheme {
+    ///             symbol: "e",
+    ///             style: Style {
+    ///                 fg: Some(Color::Yellow),
+    ///                 bg: Some(Color::Black),
+    ///                 add_modifier: Modifier::empty(),
+    ///                 sub_modifier: Modifier::empty(),
+    ///             },
+    ///         },
+    ///         StyledGrapheme {
+    ///             symbol: "x",
+    ///             style: Style {
+    ///                 fg: Some(Color::Yellow),
+    ///                 bg: Some(Color::Black),
+    ///                 add_modifier: Modifier::empty(),
+    ///                 sub_modifier: Modifier::empty(),
+    ///             },
+    ///         },
+    ///         StyledGrapheme {
+    ///             symbol: "t",
+    ///             style: Style {
+    ///                 fg: Some(Color::Yellow),
+    ///                 bg: Some(Color::Black),
+    ///                 add_modifier: Modifier::empty(),
+    ///                 sub_modifier: Modifier::empty(),
+    ///             },
+    ///         },
+    ///     ],
+    ///     styled_graphemes.collect::<Vec<StyledGrapheme>>()
+    /// );
+    /// ```
+    pub fn styled_graphemes(
+        &'a self,
+        base_style: Style,
+    ) -> impl Iterator<Item = StyledGrapheme<'a>> {
+        UnicodeSegmentation::graphemes(self.content.as_ref(), true)
+            .map(move |g| StyledGrapheme {
+                symbol: g,
+                style: base_style.patch(self.style),
+            })
+            .filter(|s| s.symbol != "\n")
+    }
+}
+
+impl<'a> From<String> for Span<'a> {
+    fn from(s: String) -> Span<'a> {
+        Span::raw(s)
+    }
+}
+
+impl<'a> From<&'a str> for Span<'a> {
+    fn from(s: &'a str) -> Span<'a> {
+        Span::raw(s)
+    }
+}
+
+/// A string composed of clusters of graphemes, each with their own style.
+#[derive(Debug, Clone, PartialEq, Default, Eq)]
+pub struct Spans<'a>(pub Vec<Span<'a>>);
+
+impl<'a> Spans<'a> {
+    /// Returns the width of the underlying string.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::text::{Span, Spans};
+    /// # use ratatui::style::{Color, Style};
+    /// let spans = Spans::from(vec![
+    ///     Span::styled("My", Style::default().fg(Color::Yellow)),
+    ///     Span::raw(" text"),
+    /// ]);
+    /// assert_eq!(7, spans.width());
+    /// ```
+    pub fn width(&self) -> usize {
+        self.0.iter().map(Span::width).sum()
+    }
+}
+
+impl<'a> From<String> for Spans<'a> {
+    fn from(s: String) -> Spans<'a> {
+        Spans(vec![Span::from(s)])
+    }
+}
+
+impl<'a> From<&'a str> for Spans<'a> {
+    fn from(s: &'a str) -> Spans<'a> {
+        Spans(vec![Span::from(s)])
+    }
+}
+
+impl<'a> From<Vec<Span<'a>>> for Spans<'a> {
+    fn from(spans: Vec<Span<'a>>) -> Spans<'a> {
+        Spans(spans)
+    }
+}
+
+impl<'a> From<Span<'a>> for Spans<'a> {
+    fn from(span: Span<'a>) -> Spans<'a> {
+        Spans(vec![span])
+    }
+}
+
+impl<'a> From<Spans<'a>> for String {
+    fn from(line: Spans<'a>) -> String {
+        line.0.iter().fold(String::new(), |mut acc, s| {
+            acc.push_str(s.content.as_ref());
+            acc
+        })
+    }
+}
+
+/// A string split over multiple lines where each line is composed of several clusters, each with
+/// their own style.
+///
+/// A [`Text`], like a [`Span`], can be constructed using one of the many `From` implementations
+/// or via the [`Text::raw`] and [`Text::styled`] methods. Helpfully, [`Text`] also implements
+/// [`core::iter::Extend`] which enables the concatenation of several [`Text`] blocks.
+///
+/// ```rust
+/// # use ratatui::text::Text;
+/// # use ratatui::style::{Color, Modifier, Style};
+/// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
+///
+/// // An initial two lines of `Text` built from a `&str`
+/// let mut text = Text::from("The first line\nThe second line");
+/// assert_eq!(2, text.height());
+///
+/// // Adding two more unstyled lines
+/// text.extend(Text::raw("These are two\nmore lines!"));
+/// assert_eq!(4, text.height());
+///
+/// // Adding a final two styled lines
+/// text.extend(Text::styled("Some more lines\nnow with more style!", style));
+/// assert_eq!(6, text.height());
+/// ```
+#[derive(Debug, Clone, PartialEq, Default, Eq)]
+pub struct Text<'a> {
+    pub lines: Vec<Spans<'a>>,
+}
+
+impl<'a> Text<'a> {
+    /// Create some text (potentially multiple lines) with no style.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use ratatui::text::Text;
+    /// Text::raw("The first line\nThe second line");
+    /// Text::raw(String::from("The first line\nThe second line"));
+    /// ```
+    pub fn raw<T>(content: T) -> Text<'a>
+    where
+        T: Into<Cow<'a, str>>,
+    {
+        let lines: Vec<_> = match content.into() {
+            Cow::Borrowed("") => vec![Spans::from("")],
+            Cow::Borrowed(s) => s.lines().map(Spans::from).collect(),
+            Cow::Owned(s) if s.is_empty() => vec![Spans::from("")],
+            Cow::Owned(s) => s.lines().map(|l| Spans::from(l.to_owned())).collect(),
+        };
+
+        Text { lines }
+    }
+
+    /// Create some text (potentially multiple lines) with a style.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ratatui::text::Text;
+    /// # use ratatui::style::{Color, Modifier, Style};
+    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
+    /// Text::styled("The first line\nThe second line", style);
+    /// Text::styled(String::from("The first line\nThe second line"), style);
+    /// ```
+    pub fn styled<T>(content: T, style: Style) -> Text<'a>
+    where
+        T: Into<Cow<'a, str>>,
+    {
+        let mut text = Text::raw(content);
+        text.patch_style(style);
+        text
+    }
+
+    /// Returns the max width of all the lines.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// use ratatui::text::Text;
+    /// let text = Text::from("The first line\nThe second line");
+    /// assert_eq!(15, text.width());
+    /// ```
+    pub fn width(&self) -> usize {
+        self.lines
+            .iter()
+            .map(Spans::width)
+            .max()
+            .unwrap_or_default()
+    }
+
+    /// Returns the height.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// use ratatui::text::Text;
+    /// let text = Text::from("The first line\nThe second line");
+    /// assert_eq!(2, text.height());
+    /// ```
+    pub fn height(&self) -> usize {
+        self.lines.len()
+    }
+
+    /// Apply a new style to existing text.
+    ///
+    /// # Examples
+    ///
+    /// ```rust
+    /// # use ratatui::text::Text;
+    /// # use ratatui::style::{Color, Modifier, Style};
+    /// let style = Style::default().fg(Color::Yellow).add_modifier(Modifier::ITALIC);
+    /// let mut raw_text = Text::raw("The first line\nThe second line");
+    /// let styled_text = Text::styled(String::from("The first line\nThe second line"), style);
+    /// assert_ne!(raw_text, styled_text);
+    ///
+    /// raw_text.patch_style(style);
+    /// assert_eq!(raw_text, styled_text);
+    /// ```
+    pub fn patch_style(&mut self, style: Style) {
+        for line in &mut self.lines {
+            for span in &mut line.0 {
+                span.style = span.style.patch(style);
+            }
+        }
+    }
+}
+
+impl<'a> From<String> for Text<'a> {
+    fn from(s: String) -> Text<'a> {
+        Text::raw(s)
+    }
+}
+
+impl<'a> From<&'a str> for Text<'a> {
+    fn from(s: &'a str) -> Text<'a> {
+        Text::raw(s)
+    }
+}
+
+impl<'a> From<Cow<'a, str>> for Text<'a> {
+    fn from(s: Cow<'a, str>) -> Text<'a> {
+        Text::raw(s)
+    }
+}
+
+impl<'a> From<Span<'a>> for Text<'a> {
+    fn from(span: Span<'a>) -> Text<'a> {
+        Text {
+            lines: vec![Spans::from(span)],
+        }
+    }
+}
+
+impl<'a> From<Spans<'a>> for Text<'a> {
+    fn from(spans: Spans<'a>) -> Text<'a> {
+        Text { lines: vec![spans] }
+    }
+}
+
+impl<'a> From<Vec<Spans<'a>>> for Text<'a> {
+    fn from(lines: Vec<Spans<'a>>) -> Text<'a> {
+        Text { lines }
+    }
+}
+
+impl<'a> IntoIterator for Text<'a> {
+    type Item = Spans<'a>;
+    type IntoIter = std::vec::IntoIter<Self::Item>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.lines.into_iter()
+    }
+}
+
+impl<'a> Extend<Spans<'a>> for Text<'a> {
+    fn extend<T: IntoIterator<Item = Spans<'a>>>(&mut self, iter: T) {
+        self.lines.extend(iter);
+    }
+}
diff --git a/src/ratatui/widgets/barchart.rs b/src/ratatui/widgets/barchart.rs
new file mode 100644
index 00000000..13f386a4
--- /dev/null
+++ b/src/ratatui/widgets/barchart.rs
@@ -0,0 +1,219 @@
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols,
+    widgets::{Block, Widget},
+};
+use std::cmp::min;
+use unicode_width::UnicodeWidthStr;
+
+/// Display multiple bars in a single widgets
+///
+/// # Examples
+///
+/// ```
+/// # use ratatui::widgets::{Block, Borders, BarChart};
+/// # use ratatui::style::{Style, Color, Modifier};
+/// BarChart::default()
+///     .block(Block::default().title("BarChart").borders(Borders::ALL))
+///     .bar_width(3)
+///     .bar_gap(1)
+///     .bar_style(Style::default().fg(Color::Yellow).bg(Color::Red))
+///     .value_style(Style::default().fg(Color::Red).add_modifier(Modifier::BOLD))
+///     .label_style(Style::default().fg(Color::White))
+///     .data(&[("B0", 0), ("B1", 2), ("B2", 4), ("B3", 3)])
+///     .max(4);
+/// ```
+#[derive(Debug, Clone)]
+pub struct BarChart<'a> {
+    /// Block to wrap the widget in
+    block: Option<Block<'a>>,
+    /// The width of each bar
+    bar_width: u16,
+    /// The gap between each bar
+    bar_gap: u16,
+    /// Set of symbols used to display the data
+    bar_set: symbols::bar::Set,
+    /// Style of the bars
+    bar_style: Style,
+    /// Style of the values printed at the bottom of each bar
+    value_style: Style,
+    /// Style of the labels printed under each bar
+    label_style: Style,
+    /// Style for the widget
+    style: Style,
+    /// Slice of (label, value) pair to plot on the chart
+    data: &'a [(&'a str, u64)],
+    /// Value necessary for a bar to reach the maximum height (if no value is specified,
+    /// the maximum value in the data is taken as reference)
+    max: Option<u64>,
+    /// Values to display on the bar (computed when the data is passed to the widget)
+    values: Vec<String>,
+}
+
+impl<'a> Default for BarChart<'a> {
+    fn default() -> BarChart<'a> {
+        BarChart {
+            block: None,
+            max: None,
+            data: &[],
+            values: Vec::new(),
+            bar_style: Style::default(),
+            bar_width: 1,
+            bar_gap: 1,
+            bar_set: symbols::bar::NINE_LEVELS,
+            value_style: Default::default(),
+            label_style: Default::default(),
+            style: Default::default(),
+        }
+    }
+}
+
+impl<'a> BarChart<'a> {
+    pub fn data(mut self, data: &'a [(&'a str, u64)]) -> BarChart<'a> {
+        self.data = data;
+        self.values = Vec::with_capacity(self.data.len());
+        for &(_, v) in self.data {
+            self.values.push(format!("{}", v));
+        }
+        self
+    }
+
+    pub fn block(mut self, block: Block<'a>) -> BarChart<'a> {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn max(mut self, max: u64) -> BarChart<'a> {
+        self.max = Some(max);
+        self
+    }
+
+    pub fn bar_style(mut self, style: Style) -> BarChart<'a> {
+        self.bar_style = style;
+        self
+    }
+
+    pub fn bar_width(mut self, width: u16) -> BarChart<'a> {
+        self.bar_width = width;
+        self
+    }
+
+    pub fn bar_gap(mut self, gap: u16) -> BarChart<'a> {
+        self.bar_gap = gap;
+        self
+    }
+
+    pub fn bar_set(mut self, bar_set: symbols::bar::Set) -> BarChart<'a> {
+        self.bar_set = bar_set;
+        self
+    }
+
+    pub fn value_style(mut self, style: Style) -> BarChart<'a> {
+        self.value_style = style;
+        self
+    }
+
+    pub fn label_style(mut self, style: Style) -> BarChart<'a> {
+        self.label_style = style;
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> BarChart<'a> {
+        self.style = style;
+        self
+    }
+}
+
+impl<'a> Widget for BarChart<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+
+        let chart_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        if chart_area.height < 2 {
+            return;
+        }
+
+        let max = self
+            .max
+            .unwrap_or_else(|| self.data.iter().map(|t| t.1).max().unwrap_or_default());
+        let max_index = min(
+            (chart_area.width / (self.bar_width + self.bar_gap)) as usize,
+            self.data.len(),
+        );
+        let mut data = self
+            .data
+            .iter()
+            .take(max_index)
+            .map(|&(l, v)| {
+                (
+                    l,
+                    v * u64::from(chart_area.height - 1) * 8 / std::cmp::max(max, 1),
+                )
+            })
+            .collect::<Vec<(&str, u64)>>();
+        for j in (0..chart_area.height - 1).rev() {
+            for (i, d) in data.iter_mut().enumerate() {
+                let symbol = match d.1 {
+                    0 => self.bar_set.empty,
+                    1 => self.bar_set.one_eighth,
+                    2 => self.bar_set.one_quarter,
+                    3 => self.bar_set.three_eighths,
+                    4 => self.bar_set.half,
+                    5 => self.bar_set.five_eighths,
+                    6 => self.bar_set.three_quarters,
+                    7 => self.bar_set.seven_eighths,
+                    _ => self.bar_set.full,
+                };
+
+                for x in 0..self.bar_width {
+                    buf.get_mut(
+                        chart_area.left() + i as u16 * (self.bar_width + self.bar_gap) + x,
+                        chart_area.top() + j,
+                    )
+                    .set_symbol(symbol)
+                    .set_style(self.bar_style);
+                }
+
+                if d.1 > 8 {
+                    d.1 -= 8;
+                } else {
+                    d.1 = 0;
+                }
+            }
+        }
+
+        for (i, &(label, value)) in self.data.iter().take(max_index).enumerate() {
+            if value != 0 {
+                let value_label = &self.values[i];
+                let width = value_label.width() as u16;
+                if width < self.bar_width {
+                    buf.set_string(
+                        chart_area.left()
+                            + i as u16 * (self.bar_width + self.bar_gap)
+                            + (self.bar_width - width) / 2,
+                        chart_area.bottom() - 2,
+                        value_label,
+                        self.value_style,
+                    );
+                }
+            }
+            buf.set_stringn(
+                chart_area.left() + i as u16 * (self.bar_width + self.bar_gap),
+                chart_area.bottom() - 1,
+                label,
+                self.bar_width as usize,
+                self.label_style,
+            );
+        }
+    }
+}
diff --git a/src/ratatui/widgets/block.rs b/src/ratatui/widgets/block.rs
new file mode 100644
index 00000000..20b43614
--- /dev/null
+++ b/src/ratatui/widgets/block.rs
@@ -0,0 +1,573 @@
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::{Alignment, Rect},
+    style::Style,
+    symbols::line,
+    text::{Span, Spans},
+    widgets::{Borders, Widget},
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BorderType {
+    Plain,
+    Rounded,
+    Double,
+    Thick,
+}
+
+impl BorderType {
+    pub fn line_symbols(border_type: BorderType) -> line::Set {
+        match border_type {
+            BorderType::Plain => line::NORMAL,
+            BorderType::Rounded => line::ROUNDED,
+            BorderType::Double => line::DOUBLE,
+            BorderType::Thick => line::THICK,
+        }
+    }
+}
+
+/// Base widget to be used with all upper level ones. It may be used to display a box border around
+/// the widget and/or add a title.
+///
+/// # Examples
+///
+/// ```
+/// # use ratatui::widgets::{Block, BorderType, Borders};
+/// # use ratatui::style::{Style, Color};
+/// Block::default()
+///     .title("Block")
+///     .borders(Borders::LEFT | Borders::RIGHT)
+///     .border_style(Style::default().fg(Color::White))
+///     .border_type(BorderType::Rounded)
+///     .style(Style::default().bg(Color::Black));
+/// ```
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Block<'a> {
+    /// Optional title place on the upper left of the block
+    title: Option<Spans<'a>>,
+    /// Title alignment. The default is top left of the block, but one can choose to place
+    /// title in the top middle, or top right of the block
+    title_alignment: Alignment,
+    /// Visible borders
+    borders: Borders,
+    /// Border style
+    border_style: Style,
+    /// Type of the border. The default is plain lines but one can choose to have rounded corners
+    /// or doubled lines instead.
+    border_type: BorderType,
+    /// Widget style
+    style: Style,
+}
+
+impl<'a> Default for Block<'a> {
+    fn default() -> Block<'a> {
+        Block {
+            title: None,
+            title_alignment: Alignment::Left,
+            borders: Borders::NONE,
+            border_style: Default::default(),
+            border_type: BorderType::Plain,
+            style: Default::default(),
+        }
+    }
+}
+
+impl<'a> Block<'a> {
+    pub fn title<T>(mut self, title: T) -> Block<'a>
+    where
+        T: Into<Spans<'a>>,
+    {
+        self.title = Some(title.into());
+        self
+    }
+
+    #[deprecated(
+        since = "0.10.0",
+        note = "You should use styling capabilities of `text::Spans` given as argument of the `title` method to apply styling to the title."
+    )]
+    pub fn title_style(mut self, style: Style) -> Block<'a> {
+        if let Some(t) = self.title {
+            let title = String::from(t);
+            self.title = Some(Spans::from(Span::styled(title, style)));
+        }
+        self
+    }
+
+    pub fn title_alignment(mut self, alignment: Alignment) -> Block<'a> {
+        self.title_alignment = alignment;
+        self
+    }
+
+    pub fn border_style(mut self, style: Style) -> Block<'a> {
+        self.border_style = style;
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Block<'a> {
+        self.style = style;
+        self
+    }
+
+    pub fn borders(mut self, flag: Borders) -> Block<'a> {
+        self.borders = flag;
+        self
+    }
+
+    pub fn border_type(mut self, border_type: BorderType) -> Block<'a> {
+        self.border_type = border_type;
+        self
+    }
+
+    /// Compute the inner area of a block based on its border visibility rules.
+    pub fn inner(&self, area: Rect) -> Rect {
+        let mut inner = area;
+        if self.borders.intersects(Borders::LEFT) {
+            inner.x = inner.x.saturating_add(1).min(inner.right());
+            inner.width = inner.width.saturating_sub(1);
+        }
+        if self.borders.intersects(Borders::TOP) || self.title.is_some() {
+            inner.y = inner.y.saturating_add(1).min(inner.bottom());
+            inner.height = inner.height.saturating_sub(1);
+        }
+        if self.borders.intersects(Borders::RIGHT) {
+            inner.width = inner.width.saturating_sub(1);
+        }
+        if self.borders.intersects(Borders::BOTTOM) {
+            inner.height = inner.height.saturating_sub(1);
+        }
+        inner
+    }
+}
+
+impl<'a> Widget for Block<'a> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        if area.area() == 0 {
+            return;
+        }
+        buf.set_style(area, self.style);
+        let symbols = BorderType::line_symbols(self.border_type);
+
+        // Sides
+        if self.borders.intersects(Borders::LEFT) {
+            for y in area.top()..area.bottom() {
+                buf.get_mut(area.left(), y)
+                    .set_symbol(symbols.vertical)
+                    .set_style(self.border_style);
+            }
+        }
+        if self.borders.intersects(Borders::TOP) {
+            for x in area.left()..area.right() {
+                buf.get_mut(x, area.top())
+                    .set_symbol(symbols.horizontal)
+                    .set_style(self.border_style);
+            }
+        }
+        if self.borders.intersects(Borders::RIGHT) {
+            let x = area.right() - 1;
+            for y in area.top()..area.bottom() {
+                buf.get_mut(x, y)
+                    .set_symbol(symbols.vertical)
+                    .set_style(self.border_style);
+            }
+        }
+        if self.borders.intersects(Borders::BOTTOM) {
+            let y = area.bottom() - 1;
+            for x in area.left()..area.right() {
+                buf.get_mut(x, y)
+                    .set_symbol(symbols.horizontal)
+                    .set_style(self.border_style);
+            }
+        }
+
+        // Corners
+        if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
+            buf.get_mut(area.right() - 1, area.bottom() - 1)
+                .set_symbol(symbols.bottom_right)
+                .set_style(self.border_style);
+        }
+        if self.borders.contains(Borders::RIGHT | Borders::TOP) {
+            buf.get_mut(area.right() - 1, area.top())
+                .set_symbol(symbols.top_right)
+                .set_style(self.border_style);
+        }
+        if self.borders.contains(Borders::LEFT | Borders::BOTTOM) {
+            buf.get_mut(area.left(), area.bottom() - 1)
+                .set_symbol(symbols.bottom_left)
+                .set_style(self.border_style);
+        }
+        if self.borders.contains(Borders::LEFT | Borders::TOP) {
+            buf.get_mut(area.left(), area.top())
+                .set_symbol(symbols.top_left)
+                .set_style(self.border_style);
+        }
+
+        // Title
+        if let Some(title) = self.title {
+            let left_border_dx = if self.borders.intersects(Borders::LEFT) {
+                1
+            } else {
+                0
+            };
+
+            let right_border_dx = if self.borders.intersects(Borders::RIGHT) {
+                1
+            } else {
+                0
+            };
+
+            let title_area_width = area
+                .width
+                .saturating_sub(left_border_dx)
+                .saturating_sub(right_border_dx);
+
+            let title_dx = match self.title_alignment {
+                Alignment::Left => left_border_dx,
+                Alignment::Center => area.width.saturating_sub(title.width() as u16) / 2,
+                Alignment::Right => area
+                    .width
+                    .saturating_sub(title.width() as u16)
+                    .saturating_sub(right_border_dx),
+            };
+
+            let title_x = area.left() + title_dx;
+            let title_y = area.top();
+
+            buf.set_spans(title_x, title_y, &title, title_area_width);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::ratatui::layout::Rect;
+
+    #[test]
+    fn inner_takes_into_account_the_borders() {
+        // No borders
+        assert_eq!(
+            Block::default().inner(Rect::default()),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 0
+            },
+            "no borders, width=0, height=0"
+        );
+        assert_eq!(
+            Block::default().inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            },
+            "no borders, width=1, height=1"
+        );
+
+        // Left border
+        assert_eq!(
+            Block::default().borders(Borders::LEFT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            },
+            "left, width=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::LEFT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 1,
+                y: 0,
+                width: 0,
+                height: 1
+            },
+            "left, width=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::LEFT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 1
+            }),
+            Rect {
+                x: 1,
+                y: 0,
+                width: 1,
+                height: 1
+            },
+            "left, width=2"
+        );
+
+        // Top border
+        assert_eq!(
+            Block::default().borders(Borders::TOP).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            },
+            "top, height=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::TOP).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 1,
+                width: 1,
+                height: 0
+            },
+            "top, height=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::TOP).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 2
+            }),
+            Rect {
+                x: 0,
+                y: 1,
+                width: 1,
+                height: 1
+            },
+            "top, height=2"
+        );
+
+        // Right border
+        assert_eq!(
+            Block::default().borders(Borders::RIGHT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            },
+            "right, width=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::RIGHT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1
+            },
+            "right, width=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::RIGHT).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            },
+            "right, width=2"
+        );
+
+        // Bottom border
+        assert_eq!(
+            Block::default().borders(Borders::BOTTOM).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            },
+            "bottom, height=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::BOTTOM).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 0
+            },
+            "bottom, height=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::BOTTOM).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 2
+            }),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            },
+            "bottom, height=2"
+        );
+
+        // All borders
+        assert_eq!(
+            Block::default()
+                .borders(Borders::ALL)
+                .inner(Rect::default()),
+            Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 0
+            },
+            "all borders, width=0, height=0"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::ALL).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 1,
+                height: 1
+            }),
+            Rect {
+                x: 1,
+                y: 1,
+                width: 0,
+                height: 0,
+            },
+            "all borders, width=1, height=1"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::ALL).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 2,
+                height: 2,
+            }),
+            Rect {
+                x: 1,
+                y: 1,
+                width: 0,
+                height: 0,
+            },
+            "all borders, width=2, height=2"
+        );
+        assert_eq!(
+            Block::default().borders(Borders::ALL).inner(Rect {
+                x: 0,
+                y: 0,
+                width: 3,
+                height: 3,
+            }),
+            Rect {
+                x: 1,
+                y: 1,
+                width: 1,
+                height: 1,
+            },
+            "all borders, width=3, height=3"
+        );
+    }
+
+    #[test]
+    fn inner_takes_into_account_the_title() {
+        assert_eq!(
+            Block::default().title("Test").inner(Rect {
+                x: 0,
+                y: 0,
+                width: 0,
+                height: 1,
+            }),
+            Rect {
+                x: 0,
+                y: 1,
+                width: 0,
+                height: 0,
+            },
+        );
+        assert_eq!(
+            Block::default()
+                .title("Test")
+                .title_alignment(Alignment::Center)
+                .inner(Rect {
+                    x: 0,
+                    y: 0,
+                    width: 0,
+                    height: 1,
+                }),
+            Rect {
+                x: 0,
+                y: 1,
+                width: 0,
+                height: 0,
+            },
+        );
+        assert_eq!(
+            Block::default()
+                .title("Test")
+                .title_alignment(Alignment::Right)
+                .inner(Rect {
+                    x: 0,
+                    y: 0,
+                    width: 0,
+                    height: 1,
+                }),
+            Rect {
+                x: 0,
+                y: 1,
+                width: 0,
+                height: 0,
+            },
+        );
+    }
+}
diff --git a/src/ratatui/widgets/canvas/line.rs b/src/ratatui/widgets/canvas/line.rs
new file mode 100644
index 00000000..84d121ce
--- /dev/null
+++ b/src/ratatui/widgets/canvas/line.rs
@@ -0,0 +1,95 @@
+use crate::ratatui::{
+    style::Color,
+    widgets::canvas::{Painter, Shape},
+};
+
+/// Shape to draw a line from (x1, y1) to (x2, y2) with the given color
+#[derive(Debug, Clone)]
+pub struct Line {
+    pub x1: f64,
+    pub y1: f64,
+    pub x2: f64,
+    pub y2: f64,
+    pub color: Color,
+}
+
+impl Shape for Line {
+    fn draw(&self, painter: &mut Painter) {
+        let (x1, y1) = match painter.get_point(self.x1, self.y1) {
+            Some(c) => c,
+            None => return,
+        };
+        let (x2, y2) = match painter.get_point(self.x2, self.y2) {
+            Some(c) => c,
+            None => return,
+        };
+        let (dx, x_range) = if x2 >= x1 {
+            (x2 - x1, x1..=x2)
+        } else {
+            (x1 - x2, x2..=x1)
+        };
+        let (dy, y_range) = if y2 >= y1 {
+            (y2 - y1, y1..=y2)
+        } else {
+            (y1 - y2, y2..=y1)
+        };
+
+        if dx == 0 {
+            for y in y_range {
+                painter.paint(x1, y, self.color);
+            }
+        } else if dy == 0 {
+            for x in x_range {
+                painter.paint(x, y1, self.color);
+            }
+        } else if dy < dx {
+            if x1 > x2 {
+                draw_line_low(painter, x2, y2, x1, y1, self.color);
+            } else {
+                draw_line_low(painter, x1, y1, x2, y2, self.color);
+            }
+        } else if y1 > y2 {
+            draw_line_high(painter, x2, y2, x1, y1, self.color);
+        } else {
+            draw_line_high(painter, x1, y1, x2, y2, self.color);
+        }
+    }
+}
+
+fn draw_line_low(painter: &mut Painter, x1: usize, y1: usize, x2: usize, y2: usize, color: Color) {
+    let dx = (x2 - x1) as isize;
+    let dy = (y2 as isize - y1 as isize).abs();
+    let mut d = 2 * dy - dx;
+    let mut y = y1;
+    for x in x1..=x2 {
+        painter.paint(x, y, color);
+        if d > 0 {
+            y = if y1 > y2 {
+                y.saturating_sub(1)
+            } else {
+                y.saturating_add(1)
+            };
+            d -= 2 * dx;
+        }
+        d += 2 * dy;
+    }
+}
+
+fn draw_line_high(painter: &mut Painter, x1: usize, y1: usize, x2: usize, y2: usize, color: Color) {
+    let dx = (x2 as isize - x1 as isize).abs();
+    let dy = (y2 - y1) as isize;
+    let mut d = 2 * dx - dy;
+    let mut x = x1;
+    for y in y1..=y2 {
+        painter.paint(x, y, color);
+        if d > 0 {
+            x = if x1 > x2 {
+                x.saturating_sub(1)
+            } else {
+                x.saturating_add(1)
+            };
+            d -= 2 * dy;
+        }
+        d += 2 * dx;
+    }
+}
diff --git a/src/ratatui/widgets/canvas/map.rs b/src/ratatui/widgets/canvas/map.rs
new file mode 100644
index 00000000..d835dd31
--- /dev/null
+++ b/src/ratatui/widgets/canvas/map.rs
@@ -0,0 +1,48 @@
+use crate::ratatui::{
+    style::Color,
+    widgets::canvas::{
+        world::{WORLD_HIGH_RESOLUTION, WORLD_LOW_RESOLUTION},
+        Painter, Shape,
+    },
+};
+
+#[derive(Debug, Clone, Copy)]
+pub enum MapResolution {
+    Low,
+    High,
+}
+
+impl MapResolution {
+    fn data(self) -> &'static [(f64, f64)] {
+        match self {
+            MapResolution::Low => &WORLD_LOW_RESOLUTION,
+            MapResolution::High => &WORLD_HIGH_RESOLUTION,
+        }
+    }
+}
+
+/// Shape to draw a world map with the given resolution and color
+#[derive(Debug, Clone)]
+pub struct Map {
+    pub resolution: MapResolution,
+    pub color: Color,
+}
+
+impl Default for Map {
+    fn default() -> Map {
+        Map {
+            resolution: MapResolution::Low,
+            color: Color::Reset,
+        }
+    }
+}
+
+impl Shape for Map {
+    fn draw(&self, painter: &mut Painter) {
+        for (x, y) in self.resolution.data() {
+            if let Some((x, y)) = painter.get_point(*x, *y) {
+                painter.paint(x, y, self.color);
+            }
+        }
+    }
+}
diff --git a/src/ratatui/widgets/canvas/mod.rs b/src/ratatui/widgets/canvas/mod.rs
new file mode 100644
index 00000000..7b174596
--- /dev/null
+++ b/src/ratatui/widgets/canvas/mod.rs
@@ -0,0 +1,510 @@
+mod line;
+mod map;
+mod points;
+mod rectangle;
+mod world;
+
+pub use self::line::Line;
+pub use self::map::{Map, MapResolution};
+pub use self::points::Points;
+pub use self::rectangle::Rectangle;
+
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    style::{Color, Style},
+    symbols,
+    text::Spans,
+    widgets::{Block, Widget},
+};
+use std::fmt::Debug;
+
+/// Interface for all shapes that may be drawn on a Canvas widget.
+pub trait Shape {
+    fn draw(&self, painter: &mut Painter);
+}
+
+/// Label to draw some text on the canvas
+#[derive(Debug, Clone)]
+pub struct Label<'a> {
+    x: f64,
+    y: f64,
+    spans: Spans<'a>,
+}
+
+#[derive(Debug, Clone)]
+struct Layer {
+    string: String,
+    colors: Vec<Color>,
+}
+
+trait Grid: Debug {
+    fn width(&self) -> u16;
+    fn height(&self) -> u16;
+    fn resolution(&self) -> (f64, f64);
+    fn paint(&mut self, x: usize, y: usize, color: Color);
+    fn save(&self) -> Layer;
+    fn reset(&mut self);
+}
+
+#[derive(Debug, Clone)]
+struct BrailleGrid {
+    width: u16,
+    height: u16,
+    cells: Vec<u16>,
+    colors: Vec<Color>,
+}
+
+impl BrailleGrid {
+    fn new(width: u16, height: u16) -> BrailleGrid {
+        let length = usize::from(width * height);
+        BrailleGrid {
+            width,
+            height,
+            cells: vec![symbols::braille::BLANK; length],
+            colors: vec![Color::Reset; length],
+        }
+    }
+}
+
+impl Grid for BrailleGrid {
+    fn width(&self) -> u16 {
+        self.width
+    }
+
+    fn height(&self) -> u16 {
+        self.height
+    }
+
+    fn resolution(&self) -> (f64, f64) {
+        (
+            f64::from(self.width) * 2.0 - 1.0,
+            f64::from(self.height) * 4.0 - 1.0,
+        )
+    }
+
+    fn save(&self) -> Layer {
+        Layer {
+            string: String::from_utf16(&self.cells).unwrap(),
+            colors: self.colors.clone(),
+        }
+    }
+
+    fn reset(&mut self) {
+        for c in &mut self.cells {
+            *c = symbols::braille::BLANK;
+        }
+        for c in &mut self.colors {
+            *c = Color::Reset;
+        }
+    }
+
+    fn paint(&mut self, x: usize, y: usize, color: Color) {
+        let index = y / 4 * self.width as usize + x / 2;
+        if let Some(c) = self.cells.get_mut(index) {
+            *c |= symbols::braille::DOTS[y % 4][x % 2];
+        }
+        if let Some(c) = self.colors.get_mut(index) {
+            *c = color;
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct CharGrid {
+    width: u16,
+    height: u16,
+    cells: Vec<char>,
+    colors: Vec<Color>,
+    cell_char: char,
+}
+
+impl CharGrid {
+    fn new(width: u16, height: u16, cell_char: char) -> CharGrid {
+        let length = usize::from(width * height);
+        CharGrid {
+            width,
+            height,
+            cells: vec![' '; length],
+            colors: vec![Color::Reset; length],
+            cell_char,
+        }
+    }
+}
+
+impl Grid for CharGrid {
+    fn width(&self) -> u16 {
+        self.width
+    }
+
+    fn height(&self) -> u16 {
+        self.height
+    }
+
+    fn resolution(&self) -> (f64, f64) {
+        (f64::from(self.width) - 1.0, f64::from(self.height) - 1.0)
+    }
+
+    fn save(&self) -> Layer {
+        Layer {
+            string: self.cells.iter().collect(),
+            colors: self.colors.clone(),
+        }
+    }
+
+    fn reset(&mut self) {
+        for c in &mut self.cells {
+            *c = ' ';
+        }
+        for c in &mut self.colors {
+            *c = Color::Reset;
+        }
+    }
+
+    fn paint(&mut self, x: usize, y: usize, color: Color) {
+        let index = y * self.width as usize + x;
+        if let Some(c) = self.cells.get_mut(index) {
+            *c = self.cell_char;
+        }
+        if let Some(c) = self.colors.get_mut(index) {
+            *c = color;
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Painter<'a, 'b> {
+    context: &'a mut Context<'b>,
+    resolution: (f64, f64),
+}
+
+impl<'a, 'b> Painter<'a, 'b> {
+    /// Convert the (x, y) coordinates to location of a point on the grid
+    ///
+    /// # Examples:
+    /// ```
+    /// use ratatui::{symbols, widgets::canvas::{Painter, Context}};
+    ///
+    /// let mut ctx = Context::new(2, 2, [1.0, 2.0], [0.0, 2.0], symbols::Marker::Braille);
+    /// let mut painter = Painter::from(&mut ctx);
+    /// let point = painter.get_point(1.0, 0.0);
+    /// assert_eq!(point, Some((0, 7)));
+    /// let point = painter.get_point(1.5, 1.0);
+    /// assert_eq!(point, Some((1, 3)));
+    /// let point = painter.get_point(0.0, 0.0);
+    /// assert_eq!(point, None);
+    /// let point = painter.get_point(2.0, 2.0);
+    /// assert_eq!(point, Some((3, 0)));
+    /// let point = painter.get_point(1.0, 2.0);
+    /// assert_eq!(point, Some((0, 0)));
+    /// ```
+    pub fn get_point(&self, x: f64, y: f64) -> Option<(usize, usize)> {
+        let left = self.context.x_bounds[0];
+        let right = self.context.x_bounds[1];
+        let top = self.context.y_bounds[1];
+        let bottom = self.context.y_bounds[0];
+        if x < left || x > right || y < bottom || y > top {
+            return None;
+        }
+        let width = (self.context.x_bounds[1] - self.context.x_bounds[0]).abs();
+        let height = (self.context.y_bounds[1] - self.context.y_bounds[0]).abs();
+        if width == 0.0 || height == 0.0 {
+            return None;
+        }
+        let x = ((x - left) * self.resolution.0 / width) as usize;
+        let y = ((top - y) * self.resolution.1 / height) as usize;
+        Some((x, y))
+    }
+
+    /// Paint a point of the grid
+    ///
+    /// # Examples:
+    /// ```
+    /// use ratatui::{style::Color, symbols, widgets::canvas::{Painter, Context}};
+    ///
+    /// let mut ctx = Context::new(1, 1, [0.0, 2.0], [0.0, 2.0], symbols::Marker::Braille);
+    /// let mut painter = Painter::from(&mut ctx);
+    /// let cell = painter.paint(1, 3, Color::Red);
+    /// ```
+    pub fn paint(&mut self, x: usize, y: usize, color: Color) {
+        self.context.grid.paint(x, y, color);
+    }
+}
+
+impl<'a, 'b> From<&'a mut Context<'b>> for Painter<'a, 'b> {
+    fn from(context: &'a mut Context<'b>) -> Painter<'a, 'b> {
+        let resolution = context.grid.resolution();
+        Painter {
+            context,
+            resolution,
+        }
+    }
+}
+
+/// Holds the state of the Canvas when painting to it.
+#[derive(Debug)]
+pub struct Context<'a> {
+    x_bounds: [f64; 2],
+    y_bounds: [f64; 2],
+    grid: Box<dyn Grid>,
+    dirty: bool,
+    layers: Vec<Layer>,
+    labels: Vec<Label<'a>>,
+}
+
+impl<'a> Context<'a> {
+    pub fn new(
+        width: u16,
+        height: u16,
+        x_bounds: [f64; 2],
+        y_bounds: [f64; 2],
+        marker: symbols::Marker,
+    ) -> Context<'a> {
+        let grid: Box<dyn Grid> = match marker {
+            symbols::Marker::Dot => Box::new(CharGrid::new(width, height, '•')),
+            symbols::Marker::Block => Box::new(CharGrid::new(width, height, '▄')),
+            symbols::Marker::Braille => Box::new(BrailleGrid::new(width, height)),
+        };
+        Context {
+            x_bounds,
+            y_bounds,
+            grid,
+            dirty: false,
+            layers: Vec::new(),
+            labels: Vec::new(),
+        }
+    }
+
+    /// Draw any object that may implement the Shape trait
+    pub fn draw<S>(&mut self, shape: &S)
+    where
+        S: Shape,
+    {
+        self.dirty = true;
+        let mut painter = Painter::from(self);
+        shape.draw(&mut painter);
+    }
+
+    /// Go one layer above in the canvas.
+    pub fn layer(&mut self) {
+        self.layers.push(self.grid.save());
+        self.grid.reset();
+        self.dirty = false;
+    }
+
+    /// Print a string on the canvas at the given position
+    pub fn print<T>(&mut self, x: f64, y: f64, spans: T)
+    where
+        T: Into<Spans<'a>>,
+    {
+        self.labels.push(Label {
+            x,
+            y,
+            spans: spans.into(),
+        });
+    }
+
+    /// Push the last layer if necessary
+    fn finish(&mut self) {
+        if self.dirty {
+            self.layer()
+        }
+    }
+}
+
+/// The Canvas widget may be used to draw more detailed figures using braille patterns (each
+/// cell can have a braille character in 8 different positions).
+/// # Examples
+///
+/// ```
+/// # use ratatui::widgets::{Block, Borders};
+/// # use ratatui::layout::Rect;
+/// # use ratatui::widgets::canvas::{Canvas, Shape, Line, Rectangle, Map, MapResolution};
+/// # use ratatui::style::Color;
+/// Canvas::default()
+///     .block(Block::default().title("Canvas").borders(Borders::ALL))
+///     .x_bounds([-180.0, 180.0])
+///     .y_bounds([-90.0, 90.0])
+///     .paint(|ctx| {
+///         ctx.draw(&Map {
+///             resolution: MapResolution::High,
+///             color: Color::White
+///         });
+///         ctx.layer();
+///         ctx.draw(&Line {
+///             x1: 0.0,
+///             y1: 10.0,
+///             x2: 10.0,
+///             y2: 10.0,
+///             color: Color::White,
+///         });
+///         ctx.draw(&Rectangle {
+///             x: 10.0,
+///             y: 20.0,
+///             width: 10.0,
+///             height: 10.0,
+///             color: Color::Red
+///         });
+///     });
+/// ```
+pub struct Canvas<'a, F>
+where
+    F: Fn(&mut Context),
+{
+    block: Option<Block<'a>>,
+    x_bounds: [f64; 2],
+    y_bounds: [f64; 2],
+    painter: Option<F>,
+    background_color: Color,
+    marker: symbols::Marker,
+}
+
+impl<'a, F> Default for Canvas<'a, F>
+where
+    F: Fn(&mut Context),
+{
+    fn default() -> Canvas<'a, F> {
+        Canvas {
+            block: None,
+            x_bounds: [0.0, 0.0],
+            y_bounds: [0.0, 0.0],
+            painter: None,
+            background_color: Color::Reset,
+            marker: symbols::Marker::Braille,
+        }
+    }
+}
+
+impl<'a, F> Canvas<'a, F>
+where
+    F: Fn(&mut Context),
+{
+    pub fn block(mut self, block: Block<'a>) -> Canvas<'a, F> {
+        self.block = Some(block);
+        self
+    }
+
+    /// Define the viewport of the canvas.
+    /// If you were to "zoom" to a certain part of the world you may want to choose different
+    /// bounds.
+    pub fn x_bounds(mut self, bounds: [f64; 2]) -> Canvas<'a, F> {
+        self.x_bounds = bounds;
+        self
+    }
+
+    /// Define the viewport of the canvas.
+    ///
+    /// If you were to "zoom" to a certain part of the world you may want to choose different
+    /// bounds.
+    pub fn y_bounds(mut self, bounds: [f64; 2]) -> Canvas<'a, F> {
+        self.y_bounds = bounds;
+        self
+    }
+
+    /// Store the closure that will be used to draw to the Canvas
+    pub fn paint(mut self, f: F) -> Canvas<'a, F> {
+        self.painter = Some(f);
+        self
+    }
+
+    pub fn background_color(mut self, color: Color) -> Canvas<'a, F> {
+        self.background_color = color;
+        self
+    }
+
+    /// Change the type of points used to draw the shapes. By default the braille patterns are used
+    /// as they provide a more fine grained result but you might want to use the simple dot or
+    /// block instead if the targeted terminal does not support those symbols.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use ratatui::widgets::canvas::Canvas;
+    /// # use ratatui::symbols;
+    /// Canvas::default().marker(symbols::Marker::Braille).paint(|ctx| {});
+    ///
+    /// Canvas::default().marker(symbols::Marker::Dot).paint(|ctx| {});
+    ///
+    /// Canvas::default().marker(symbols::Marker::Block).paint(|ctx| {});
+    /// ```
+    pub fn marker(mut self, marker: symbols::Marker) -> Canvas<'a, F> {
+        self.marker = marker;
+        self
+    }
+}
+
+impl<'a, F> Widget for Canvas<'a, F>
+where
+    F: Fn(&mut Context),
+{
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        let canvas_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        buf.set_style(canvas_area, Style::default().bg(self.background_color));
+
+        let width = canvas_area.width as usize;
+
+        let painter = match self.painter {
+            Some(ref p) => p,
+            None => return,
+        };
+
+        // Create a blank context that match the size of the canvas
+        let mut ctx = Context::new(
+            canvas_area.width,
+            canvas_area.height,
+            self.x_bounds,
+            self.y_bounds,
+            self.marker,
+        );
+        // Paint to this context
+        painter(&mut ctx);
+        ctx.finish();
+
+        // Retrieve painted points for each layer
+        for layer in ctx.layers {
+            for (i, (ch, color)) in layer
+                .string
+                .chars()
+                .zip(layer.colors.into_iter())
+                .enumerate()
+            {
+                if ch != ' ' && ch != '\u{2800}' {
+                    let (x, y) = (i % width, i / width);
+                    buf.get_mut(x as u16 + canvas_area.left(), y as u16 + canvas_area.top())
+                        .set_char(ch)
+                        .set_fg(color);
+                }
+            }
+        }
+
+        // Finally draw the labels
+        let left = self.x_bounds[0];
+        let right = self.x_bounds[1];
+        let top = self.y_bounds[1];
+        let bottom = self.y_bounds[0];
+        let width = (self.x_bounds[1] - self.x_bounds[0]).abs();
+        let height = (self.y_bounds[1] - self.y_bounds[0]).abs();
+        let resolution = {
+            let width = f64::from(canvas_area.width - 1);
+            let height = f64::from(canvas_area.height - 1);
+            (width, height)
+        };
+        for label in ctx
+            .labels
+            .iter()
+            .filter(|l| l.x >= left && l.x <= right && l.y <= top && l.y >= bottom)
+        {
+            let x = ((label.x - left) * resolution.0 / width) as u16 + canvas_area.left();
+            let y = ((top - label.y) * resolution.1 / height) as u16 + canvas_area.top();
+            buf.set_spans(x, y, &label.spans, canvas_area.right() - x);
+        }
+    }
+}
diff --git a/src/ratatui/widgets/canvas/points.rs b/src/ratatui/widgets/canvas/points.rs
new file mode 100644
index 00000000..d9f97522
--- /dev/null
+++ b/src/ratatui/widgets/canvas/points.rs
@@ -0,0 +1,30 @@
+use crate::ratatui::{
+    style::Color,
+    widgets::canvas::{Painter, Shape},
+};
+
+/// A shape to draw a group of points with the given color
+#[derive(Debug, Clone)]
+pub struct Points<'a> {
+    pub coords: &'a [(f64, f64)],
+    pub color: Color,
+}
+
+impl<'a> Shape for Points<'a> {
+    fn draw(&self, painter: &mut Painter) {
+        for (x, y) in self.coords {
+            if let Some((x, y)) = painter.get_point(*x, *y) {
+                painter.paint(x, y, self.color);
+            }
+        }
+    }
+}
+
+impl<'a> Default for Points<'a> {
+    fn default() -> Points<'a> {
+        Points {
+            coords: &[],
+            color: Color::Reset,
+        }
+    }
+}
diff --git a/src/ratatui/widgets/canvas/rectangle.rs b/src/ratatui/widgets/canvas/rectangle.rs
new file mode 100644
index 00000000..07ac9137
--- /dev/null
+++ b/src/ratatui/widgets/canvas/rectangle.rs
@@ -0,0 +1,52 @@
+use crate::ratatui::{
+    style::Color,
+    widgets::canvas::{Line, Painter, Shape},
+};
+
+/// Shape to draw a rectangle from a `Rect` with the given color
+#[derive(Debug, Clone)]
+pub struct Rectangle {
+    pub x: f64,
+    pub y: f64,
+    pub width: f64,
+    pub height: f64,
+    pub color: Color,
+}
+
+impl Shape for Rectangle {
+    fn draw(&self, painter: &mut Painter) {
+        let lines: [Line; 4] = [
+            Line {
+                x1: self.x,
+                y1: self.y,
+                x2: self.x,
+                y2: self.y + self.height,
+                color: self.color,
+            },
+            Line {
+                x1: self.x,
+                y1: self.y + self.height,
+                x2: self.x + self.width,
+                y2: self.y + self.height,
+                color: self.color,
+            },
+            Line {
+                x1: self.x + self.width,
+                y1: self.y,
+                x2: self.x + self.width,
+                y2: self.y + self.height,
+                color: self.color,
+            },
+            Line {
+                x1: self.x,
+                y1: self.y,
+                x2: self.x + self.width,
+                y2: self.y,
+                color: self.color,
+            },
+        ];
+        for line in &lines {
+            line.draw(painter);
+        }
+    }
+}
diff --git a/src/ratatui/widgets/canvas/world.rs b/src/ratatui/widgets/canvas/world.rs
new file mode 100644
index 00000000..b15b7c32
--- /dev/null
+++ b/src/ratatui/widgets/canvas/world.rs
@@ -0,0 +1,6299 @@
+/// [Source data](http://www.gnuplotting.org/plotting-the-world-revisited)
+
+pub static WORLD_HIGH_RESOLUTION: [(f64, f64); 5125] = [
+    (-163.7128, -78.5956),
+    (-163.1058, -78.2233),
+    (-161.2451, -78.3801),
+    (-160.2462, -78.6936),
+    (-159.4824, -79.0463),
+    (-159.2081, -79.4970),
+    (-161.1276, -79.6342),
+    (-162.4398, -79.2814),
+    (-163.0274, -78.9287),
+    (-163.0666, -78.8699),
+    (-163.7128, -78.5956),
+    (-6.1978, 53.8675),
+    (-6.0329, 53.1531),
+    (-6.7888, 52.2601),
+    (-8.5616, 51.6693),
+    (-9.9770, 51.8204),
+    (-9.1662, 52.8646),
+    (-9.6885, 53.8813),
+    (-8.3279, 54.6645),
+    (-7.5721, 55.1316),
+    (-6.7338, 55.1728),
+    (-5.6619, 54.5546),
+    (-6.1978, 53.8675),
+    (141.0002, -2.6001),
+    (142.7352, -3.2891),
+    (144.5839, -3.8614),
+    (145.2731, -4.3737),
+    (145.8297, -4.8764),
+    (145.9819, -5.4656),
+    (147.6480, -6.0836),
+    (147.8911, -6.6140),
+    (146.9709, -6.7216),
+    (147.1918, -7.3880),
+    (148.0846, -8.0441),
+    (148.7341, -9.1046),
+    (149.3068, -9.0714),
+    (149.2666, -9.5144),
+    (150.0387, -9.6843),
+    (149.7387, -9.8729),
+    (150.8016, -10.2936),
+    (150.6905, -10.5827),
+    (150.0283, -10.6524),
+    (149.7823, -10.3932),
+    (148.9231, -10.2809),
+    (147.9130, -10.1304),
+    (147.1354, -9.4924),
+    (146.5678, -8.9425),
+    (146.0484, -8.0674),
+    (144.7441, -7.6301),
+    (143.8970, -7.9153),
+    (143.2863, -8.2454),
+    (143.4139, -8.9830),
+    (142.6284, -9.3268),
+    (142.0682, -9.1595),
+    (141.0338, -9.1178),
+    (140.1434, -8.2971),
+    (139.1277, -8.0960),
+    (138.8814, -8.3809),
+    (137.6144, -8.4116),
+    (138.0390, -7.5978),
+    (138.6686, -7.3202),
+    (138.4079, -6.2328),
+    (137.9278, -5.3933),
+    (135.9892, -4.5465),
+    (135.1645, -4.4629),
+    (133.6628, -3.5388),
+    (133.3677, -4.0248),
+    (132.9839, -4.1129),
+    (132.7569, -3.7462),
+    (132.7537, -3.3117),
+    (131.9898, -2.8205),
+    (133.0668, -2.4604),
+    (133.7800, -2.4798),
+    (133.6962, -2.2145),
+    (132.2323, -2.2125),
+    (131.8362, -1.6171),
+    (130.9428, -1.4325),
+    (130.5195, -0.9377),
+    (131.8675, -0.6954),
+    (132.3801, -0.3695),
+    (133.9855, -0.7802),
+    (134.1433, -1.1518),
+    (134.4226, -2.7691),
+    (135.4576, -3.3677),
+    (136.2933, -2.3070),
+    (137.4407, -1.7035),
+    (138.3297, -1.7026),
+    (139.1849, -2.0512),
+    (139.9266, -2.4089),
+    (141.0002, -2.6001),
+    (114.2040, 4.5258),
+    (114.5999, 4.9000),
+    (115.4507, 5.4477),
+    (116.2207, 6.1431),
+    (116.7251, 6.9247),
+    (117.1296, 6.9280),
+    (117.6433, 6.4221),
+    (117.6890, 5.9874),
+    (118.3476, 5.7086),
+    (119.1819, 5.4078),
+    (119.1106, 5.0161),
+    (118.4397, 4.9665),
+    (118.6183, 4.4782),
+    (117.8820, 4.1375),
+    (117.3132, 3.2344),
+    (118.0483, 2.2876),
+    (117.8756, 1.8276),
+    (118.9967, 0.9022),
+    (117.8118, 0.7842),
+    (117.4783, 0.1024),
+    (117.5216, -0.8037),
+    (116.5600, -1.4876),
+    (116.5337, -2.4835),
+    (116.1480, -4.0127),
+    (116.0008, -3.6570),
+    (114.8648, -4.1069),
+    (114.4686, -3.4957),
+    (113.7556, -3.4391),
+    (113.2569, -3.1187),
+    (112.0681, -3.4783),
+    (111.7032, -2.9944),
+    (111.0482, -3.0494),
+    (110.2238, -2.9340),
+    (110.0709, -1.5928),
+    (109.5719, -1.3149),
+    (109.0918, -0.4595),
+    (108.9526, 0.4153),
+    (109.0691, 1.3419),
+    (109.6632, 2.0064),
+    (110.3961, 1.6637),
+    (111.1688, 1.8506),
+    (111.3700, 2.6973),
+    (111.7969, 2.8858),
+    (112.9956, 3.1023),
+    (113.7129, 3.8935),
+    (114.2040, 4.5258),
+    (-93.6127, 74.9799),
+    (-94.1569, 74.5923),
+    (-95.6086, 74.6668),
+    (-96.8209, 74.9276),
+    (-96.2885, 75.3778),
+    (-94.8508, 75.6472),
+    (-93.9777, 75.2964),
+    (-93.6127, 74.9799),
+    (-93.8400, 77.5199),
+    (-94.2956, 77.4913),
+    (-96.1696, 77.5551),
+    (-96.4363, 77.8346),
+    (-94.4225, 77.8200),
+    (-93.7206, 77.6343),
+    (-93.8400, 77.5199),
+    (-96.7543, 78.7658),
+    (-95.5592, 78.4183),
+    (-95.8302, 78.0569),
+    (-97.3098, 77.8505),
+    (-98.1242, 78.0828),
+    (-98.5528, 78.4581),
+    (-98.6319, 78.8719),
+    (-97.3372, 78.8319),
+    (-96.7543, 78.7658),
+    (-88.1503, 74.3923),
+    (-89.7647, 74.5155),
+    (-92.4224, 74.8377),
+    (-92.7682, 75.3868),
+    (-92.8899, 75.8826),
+    (-93.8938, 76.3192),
+    (-95.9624, 76.4413),
+    (-97.1213, 76.7510),
+    (-96.7451, 77.1613),
+    (-94.6840, 77.0978),
+    (-93.5739, 76.7762),
+    (-91.6050, 76.7785),
+    (-90.7418, 76.4495),
+    (-90.9696, 76.0740),
+    (-89.8222, 75.8477),
+    (-89.1870, 75.6101),
+    (-87.8382, 75.5661),
+    (-86.3791, 75.4824),
+    (-84.7896, 75.6992),
+    (-82.7534, 75.7843),
+    (-81.1285, 75.7139),
+    (-80.0575, 75.3368),
+    (-79.8339, 74.9231),
+    (-80.4577, 74.6573),
+    (-81.9488, 74.4424),
+    (-83.2288, 74.5640),
+    (-86.0974, 74.4100),
+    (-88.1503, 74.3923),
+    (-111.2644, 78.1529),
+    (-109.8544, 77.9963),
+    (-110.1869, 77.6970),
+    (-112.0511, 77.4092),
+    (-113.5342, 77.7322),
+    (-112.7245, 78.0510),
+    (-111.2644, 78.1529),
+    (-110.9636, 78.8044),
+    (-109.6631, 78.6019),
+    (-110.8813, 78.4069),
+    (-112.5420, 78.4079),
+    (-112.5258, 78.5505),
+    (-111.5000, 78.8499),
+    (-110.9636, 78.8044),
+    (-66.2824, 18.5147),
+    (-65.7713, 18.4266),
+    (-65.5910, 18.2280),
+    (-65.8471, 17.9759),
+    (-66.5999, 17.9818),
+    (-67.1841, 17.9465),
+    (-67.2424, 18.3744),
+    (-67.1006, 18.5206),
+    (-66.2824, 18.5147),
+    (-77.5696, 18.4905),
+    (-76.8966, 18.4008),
+    (-76.3653, 18.1607),
+    (-76.1996, 17.8868),
+    (-76.9025, 17.8682),
+    (-77.2063, 17.7011),
+    (-77.7660, 17.8615),
+    (-78.3377, 18.2259),
+    (-78.2177, 18.4545),
+    (-77.7973, 18.5242),
+    (-77.5696, 18.4905),
+    (-82.2681, 23.1886),
+    (-81.4044, 23.1172),
+    (-80.6187, 23.1060),
+    (-79.6795, 22.7653),
+    (-79.2814, 22.3992),
+    (-78.3474, 22.5121),
+    (-77.9932, 22.2771),
+    (-77.1464, 21.6578),
+    (-76.5238, 21.2068),
+    (-76.1946, 21.2205),
+    (-75.5982, 21.0166),
+    (-75.6710, 20.7350),
+    (-74.9338, 20.6939),
+    (-74.1780, 20.2846),
+    (-74.2966, 20.0503),
+    (-74.9615, 19.9234),
+    (-75.6346, 19.8737),
+    (-76.3236, 19.9528),
+    (-77.7554, 19.8554),
+    (-77.0851, 20.4133),
+    (-77.4926, 20.6731),
+    (-78.1372, 20.7399),
+    (-78.4828, 21.0286),
+    (-78.7198, 21.5981),
+    (-79.2849, 21.5591),
+    (-80.2174, 21.8273),
+    (-80.5175, 22.0370),
+    (-81.8209, 22.1920),
+    (-82.1699, 22.3871),
+    (-81.7950, 22.6369),
+    (-82.7758, 22.6881),
+    (-83.4944, 22.1685),
+    (-83.9088, 22.1545),
+    (-84.0521, 21.9105),
+    (-84.5470, 21.8012),
+    (-84.9749, 21.8960),
+    (-84.4470, 22.2049),
+    (-84.2303, 22.5657),
+    (-83.7782, 22.7881),
+    (-83.2675, 22.9830),
+    (-82.5104, 23.0787),
+    (-82.2681, 23.1886),
+    (-55.6002, 51.3170),
+    (-56.1340, 50.6870),
+    (-56.7958, 49.8123),
+    (-56.1431, 50.1501),
+    (-55.4714, 49.9358),
+    (-55.8224, 49.5871),
+    (-54.9351, 49.3130),
+    (-54.4737, 49.5566),
+    (-53.4765, 49.2491),
+    (-53.7860, 48.5167),
+    (-53.0861, 48.6878),
+    (-52.9586, 48.1571),
+    (-52.6480, 47.5355),
+    (-53.0691, 46.6554),
+    (-53.5214, 46.6182),
+    (-54.1789, 46.8070),
+    (-53.9618, 47.6252),
+    (-54.2404, 47.7522),
+    (-55.4007, 46.8849),
+    (-55.9974, 46.9197),
+    (-55.2912, 47.3895),
+    (-56.2507, 47.6325),
+    (-57.3252, 47.5728),
+    (-59.2660, 47.6033),
+    (-59.4194, 47.8994),
+    (-58.7965, 48.2515),
+    (-59.2316, 48.5231),
+    (-58.3918, 49.1255),
+    (-57.3586, 50.7182),
+    (-56.7386, 51.2874),
+    (-55.8709, 51.6320),
+    (-55.4069, 51.5882),
+    (-55.6002, 51.3170),
+    (-83.8826, 65.1096),
+    (-82.7875, 64.7666),
+    (-81.6420, 64.4551),
+    (-81.5534, 63.9796),
+    (-80.8173, 64.0574),
+    (-80.1034, 63.7259),
+    (-80.9910, 63.4112),
+    (-82.5471, 63.6517),
+    (-83.1087, 64.1018),
+    (-84.1004, 63.5697),
+    (-85.5234, 63.0523),
+    (-85.8667, 63.6372),
+    (-87.2219, 63.5412),
+    (-86.3527, 64.0358),
+    (-86.2248, 64.8229),
+    (-85.8838, 65.7387),
+    (-85.1613, 65.6572),
+    (-84.9757, 65.2175),
+    (-84.4640, 65.3717),
+    (-83.8826, 65.1096),
+    (-78.7706, 72.3521),
+    (-77.8246, 72.7496),
+    (-75.6058, 72.2436),
+    (-74.2286, 71.7671),
+    (-74.0991, 71.3308),
+    (-72.2422, 71.5569),
+    (-71.2000, 70.9200),
+    (-68.7860, 70.5250),
+    (-67.9149, 70.1219),
+    (-66.9690, 69.1860),
+    (-68.8051, 68.7201),
+    (-66.4498, 68.0671),
+    (-64.8623, 67.8475),
+    (-63.4249, 66.9284),
+    (-61.8519, 66.8621),
+    (-62.1631, 66.1602),
+    (-63.9184, 64.9986),
+    (-65.1488, 65.4260),
+    (-66.7212, 66.3880),
+    (-68.0150, 66.2627),
+    (-68.1412, 65.6897),
+    (-67.0896, 65.1084),
+    (-65.7320, 64.6484),
+    (-65.3201, 64.3827),
+    (-64.6694, 63.3929),
+    (-65.0138, 62.6741),
+    (-66.2750, 62.9450),
+    (-68.7831, 63.7456),
+    (-67.3696, 62.8839),
+    (-66.3282, 62.2800),
+    (-66.1655, 61.9308),
+    (-68.8773, 62.3301),
+    (-71.0234, 62.9107),
+    (-72.2353, 63.3978),
+    (-71.8862, 63.6799),
+    (-73.3783, 64.1939),
+    (-74.8344, 64.6791),
+    (-74.8185, 64.3890),
+    (-77.7099, 64.2295),
+    (-78.5559, 64.5729),
+    (-77.8972, 65.3091),
+    (-76.0182, 65.3269),
+    (-73.9597, 65.4547),
+    (-74.2938, 65.8117),
+    (-73.9449, 66.3105),
+    (-72.6511, 67.2845),
+    (-72.9260, 67.7269),
+    (-73.3116, 68.0694),
+    (-74.8433, 68.5546),
+    (-76.8691, 68.8947),
+    (-76.2286, 69.1477),
+    (-77.2873, 69.7695),
+    (-78.1686, 69.8264),
+    (-78.9572, 70.1668),
+    (-79.4924, 69.8718),
+    (-81.3054, 69.7431),
+    (-84.9447, 69.9666),
+    (-87.0600, 70.2600),
+    (-88.6817, 70.4107),
+    (-89.5134, 70.7620),
+    (-88.4677, 71.2181),
+    (-89.8881, 71.2225),
+    (-90.2051, 72.2350),
+    (-89.4365, 73.1294),
+    (-88.4082, 73.5378),
+    (-85.8261, 73.8038),
+    (-86.5621, 73.1574),
+    (-85.7743, 72.5341),
+    (-84.8501, 73.3402),
+    (-82.3155, 73.7509),
+    (-80.6000, 72.7165),
+    (-80.7489, 72.0619),
+    (-78.7706, 72.3521),
+    (-94.5036, 74.1349),
+    (-92.4200, 74.1000),
+    (-90.5097, 73.8567),
+    (-92.0039, 72.9662),
+    (-93.1962, 72.7719),
+    (-94.2690, 72.0245),
+    (-95.4098, 72.0618),
+    (-96.0337, 72.9402),
+    (-96.0182, 73.4374),
+    (-95.4957, 73.8624),
+    (-94.5036, 74.1349),
+    (-100.4383, 72.7058),
+    (-101.54, 73.36),
+    (-100.3564, 73.8438),
+    (-99.1638, 73.6333),
+    (-97.38, 73.76),
+    (-97.12, 73.47),
+    (-98.0535, 72.9905),
+    (-96.54, 72.56),
+    (-96.72, 71.66),
+    (-98.3596, 71.2728),
+    (-99.3228, 71.3563),
+    (-100.0148, 71.7382),
+    (-102.48, 72.4829),
+    (-102.48, 72.83),
+    (-100.4383, 72.7058),
+    (-107.8194, 75.8455),
+    (-106.9289, 76.0128),
+    (-105.8809, 75.9693),
+    (-105.7049, 75.4795),
+    (-106.3134, 75.0052),
+    (-109.6999, 74.8500),
+    (-112.2230, 74.4169),
+    (-113.7438, 74.3942),
+    (-113.8713, 74.7202),
+    (-111.7942, 75.1624),
+    (-116.3121, 75.0434),
+    (-117.7104, 75.2222),
+    (-116.3460, 76.1990),
+    (-115.4048, 76.4788),
+    (-112.5905, 76.1413),
+    (-110.8142, 75.5491),
+    (-109.0671, 75.4732),
+    (-110.4972, 76.4298),
+    (-109.5811, 76.7941),
+    (-108.5485, 76.6783),
+    (-108.2114, 76.2016),
+    (-107.8194, 75.8455),
+    (-122.8549, 76.1165),
+    (-121.1575, 76.8645),
+    (-119.1039, 77.5122),
+    (-117.5701, 77.4983),
+    (-116.1985, 77.6452),
+    (-116.3358, 76.8769),
+    (-117.1060, 76.5300),
+    (-118.0404, 76.4811),
+    (-119.8993, 76.0532),
+    (-121.4999, 75.9000),
+    (-122.8549, 76.1165),
+    (-121.5378, 74.4489),
+    (-120.1097, 74.2413),
+    (-117.5556, 74.1857),
+    (-116.5844, 73.8960),
+    (-115.5107, 73.4752),
+    (-116.7679, 73.2229),
+    (-119.22, 72.52),
+    (-120.46, 71.82),
+    (-120.46, 71.3836),
+    (-123.0921, 70.9016),
+    (-123.62, 71.34),
+    (-125.9289, 71.8686),
+    (-125.5, 72.2922),
+    (-124.8072, 73.0225),
+    (-123.94, 73.68),
+    (-124.9177, 74.2927),
+    (-121.5378, 74.4489),
+    (-166.4677, 60.3841),
+    (-165.6744, 60.2936),
+    (-165.5791, 59.9099),
+    (-166.1927, 59.7544),
+    (-166.8483, 59.9414),
+    (-167.4552, 60.2130),
+    (-166.4677, 60.3841),
+    (-153.2287, 57.9690),
+    (-152.5647, 57.9014),
+    (-152.1411, 57.5910),
+    (-153.0063, 57.1158),
+    (-154.0050, 56.7346),
+    (-154.5164, 56.9927),
+    (-154.6709, 57.4611),
+    (-153.7627, 57.8165),
+    (-153.2287, 57.9690),
+    (-132.7100, 54.0400),
+    (-131.7499, 54.1200),
+    (-132.0494, 52.9846),
+    (-131.1790, 52.1804),
+    (-131.5778, 52.1823),
+    (-132.1804, 52.6397),
+    (-132.5499, 53.1000),
+    (-133.0546, 53.4114),
+    (-133.2396, 53.8510),
+    (-133.1800, 54.1699),
+    (-132.7100, 54.0400),
+    (-125.4150, 49.9500),
+    (-124.9207, 49.4752),
+    (-123.9225, 49.0624),
+    (-123.5100, 48.5100),
+    (-124.0128, 48.3708),
+    (-125.6550, 48.8250),
+    (-125.9549, 49.1799),
+    (-126.8500, 49.5300),
+    (-127.0299, 49.8149),
+    (-128.0593, 49.9949),
+    (-128.4445, 50.5391),
+    (-128.3584, 50.7706),
+    (-127.3085, 50.5525),
+    (-126.6950, 50.4009),
+    (-125.7550, 50.2950),
+    (-125.4150, 49.9500),
+    (-171.7316, 63.7825),
+    (-171.1144, 63.5921),
+    (-170.4911, 63.6949),
+    (-169.6825, 63.4311),
+    (-168.6894, 63.2975),
+    (-168.7719, 63.1885),
+    (-169.5294, 62.9769),
+    (-170.2905, 63.1944),
+    (-170.6713, 63.3758),
+    (-171.5530, 63.3177),
+    (-171.7911, 63.4058),
+    (-171.7316, 63.7825),
+    (-105.4922, 79.3015),
+    (-103.5292, 79.1653),
+    (-100.8251, 78.8004),
+    (-100.0601, 78.3247),
+    (-99.6709, 77.9075),
+    (-101.3039, 78.0189),
+    (-102.9498, 78.3432),
+    (-105.1761, 78.3803),
+    (-104.2104, 78.6774),
+    (-105.4195, 78.9183),
+    (-105.4922, 79.3015),
+    (32.9469, 35.3867),
+    (33.6672, 35.3732),
+    (34.5764, 35.6715),
+    (33.9008, 35.2457),
+    (34.0048, 34.9780),
+    (32.9798, 34.5718),
+    (32.4902, 34.7016),
+    (32.2566, 35.1032),
+    (32.8024, 35.1455),
+    (32.9469, 35.3867),
+    (26.2900, 35.2999),
+    (26.1649, 35.0049),
+    (24.7249, 34.9199),
+    (24.7350, 35.0849),
+    (23.5149, 35.2799),
+    (23.6999, 35.7050),
+    (24.2466, 35.3680),
+    (25.0250, 35.4249),
+    (25.7692, 35.3540),
+    (25.7450, 35.1799),
+    (26.2900, 35.2999),
+    (49.5435, -12.4698),
+    (49.8089, -12.8952),
+    (50.0565, -13.5557),
+    (50.2174, -14.7587),
+    (50.4765, -15.2265),
+    (50.3771, -15.7060),
+    (50.2002, -16.0002),
+    (49.8606, -15.4142),
+    (49.6726, -15.7101),
+    (49.8633, -16.4510),
+    (49.7745, -16.8750),
+    (49.4986, -17.1060),
+    (49.4356, -17.9530),
+    (49.0417, -19.1187),
+    (48.5485, -20.4968),
+    (47.9307, -22.3915),
+    (47.5477, -23.7819),
+    (47.0957, -24.9416),
+    (46.2824, -25.1784),
+    (45.4095, -25.6014),
+    (44.8335, -25.3461),
+    (44.0397, -24.9883),
+    (43.7637, -24.4606),
+    (43.6977, -23.5741),
+    (43.3456, -22.7769),
+    (43.2541, -22.0574),
+    (43.4332, -21.3364),
+    (43.8936, -21.1633),
+    (43.8963, -20.8304),
+    (44.3743, -20.0723),
+    (44.4643, -19.4354),
+    (44.2324, -18.9619),
+    (44.0429, -18.3313),
+    (43.9630, -17.4099),
+    (44.3124, -16.8504),
+    (44.4465, -16.2162),
+    (44.9449, -16.1793),
+    (45.5027, -15.9743),
+    (45.8729, -15.7934),
+    (46.3122, -15.7800),
+    (46.8821, -15.2101),
+    (47.7051, -14.5943),
+    (48.0052, -14.0912),
+    (47.8689, -13.6638),
+    (48.2938, -13.7840),
+    (48.8450, -13.0891),
+    (48.8635, -12.4878),
+    (49.1946, -12.0405),
+    (49.5435, -12.4698),
+    (167.2168, -15.8918),
+    (167.8448, -16.4663),
+    (167.5151, -16.5978),
+    (167.1800, -16.1599),
+    (167.2168, -15.8918),
+    (166.7931, -15.6688),
+    (166.6498, -15.3927),
+    (166.6291, -14.6264),
+    (167.1077, -14.9339),
+    (167.2700, -15.7400),
+    (167.0012, -15.6146),
+    (166.7931, -15.6688),
+    (134.2101, -6.8952),
+    (134.1127, -6.1424),
+    (134.2903, -5.7830),
+    (134.4996, -5.4450),
+    (134.7270, -5.7375),
+    (134.7246, -6.2144),
+    (134.2101, -6.8952),
+    (-48.6606, -78.0470),
+    (-48.1513, -78.0470),
+    (-46.6628, -77.8314),
+    (-45.1547, -78.0470),
+    (-43.9208, -78.4781),
+    (-43.4899, -79.0855),
+    (-43.3724, -79.5166),
+    (-43.3332, -80.0261),
+    (-44.8805, -80.3396),
+    (-46.5061, -80.5943),
+    (-48.3864, -80.8294),
+    (-50.4821, -81.0254),
+    (-52.8519, -80.9666),
+    (-54.1642, -80.6335),
+    (-53.9879, -80.2220),
+    (-51.8531, -79.9477),
+    (-50.9913, -79.6146),
+    (-50.3645, -79.1834),
+    (-49.9141, -78.8112),
+    (-49.3069, -78.4585),
+    (-48.6606, -78.0470),
+    (-66.2900, -80.2557),
+    (-64.0376, -80.2948),
+    (-61.8832, -80.3928),
+    (-61.1389, -79.9813),
+    (-60.6101, -79.6286),
+    (-59.5720, -80.0401),
+    (-59.8658, -80.5496),
+    (-60.1596, -81.0003),
+    (-62.2553, -80.8631),
+    (-64.4881, -80.9219),
+    (-65.7416, -80.5888),
+    (-65.7416, -80.5496),
+    (-66.2900, -80.2557),
+    (-73.9158, -71.2693),
+    (-73.2303, -71.1517),
+    (-72.0747, -71.1909),
+    (-71.7809, -70.6814),
+    (-71.7221, -70.3091),
+    (-71.7417, -69.5057),
+    (-71.1738, -69.0354),
+    (-70.2532, -68.8787),
+    (-69.7244, -69.2510),
+    (-69.4894, -69.6233),
+    (-69.0585, -70.0740),
+    (-68.7255, -70.5051),
+    (-68.4513, -70.9558),
+    (-68.3338, -71.4064),
+    (-68.5101, -71.7984),
+    (-68.7842, -72.1706),
+    (-69.9594, -72.3078),
+    (-71.0758, -72.5038),
+    (-72.3881, -72.4842),
+    (-71.8984, -72.0923),
+    (-73.0736, -72.2294),
+    (-74.1900, -72.3666),
+    (-74.9538, -72.0727),
+    (-75.0126, -71.6612),
+    (-73.9158, -71.2693),
+    (-102.3307, -71.8941),
+    (-101.7039, -71.7177),
+    (-100.4309, -71.8549),
+    (-98.9815, -71.9333),
+    (-97.8847, -72.0705),
+    (-96.7879, -71.9529),
+    (-96.2003, -72.5212),
+    (-96.9837, -72.4428),
+    (-98.1980, -72.4820),
+    (-99.4320, -72.4428),
+    (-100.7834, -72.5016),
+    (-101.8018, -72.3056),
+    (-102.3307, -71.8941),
+    (-122.6217, -73.6577),
+    (-122.4062, -73.3246),
+    (-121.2115, -73.5009),
+    (-119.9188, -73.6577),
+    (-118.7241, -73.4813),
+    (-119.2921, -73.8340),
+    (-120.2322, -74.0888),
+    (-121.6228, -74.0104),
+    (-122.6217, -73.6577),
+    (-127.2831, -73.4617),
+    (-126.5584, -73.2462),
+    (-125.5595, -73.4813),
+    (-124.0318, -73.8732),
+    (-124.6194, -73.8340),
+    (-125.9121, -73.7361),
+    (-127.2831, -73.4617),
+    (165.7799, -21.0800),
+    (166.5999, -21.7000),
+    (167.1200, -22.1599),
+    (166.7400, -22.3999),
+    (166.1897, -22.1297),
+    (165.4743, -21.6796),
+    (164.8298, -21.1498),
+    (164.1679, -20.4447),
+    (164.0296, -20.1056),
+    (164.4599, -20.1200),
+    (165.0200, -20.4599),
+    (165.4600, -20.8000),
+    (165.7799, -21.0800),
+    (152.6400, -3.6599),
+    (153.0199, -3.9800),
+    (153.1400, -4.4999),
+    (152.8272, -4.7664),
+    (152.6386, -4.1761),
+    (152.4060, -3.7897),
+    (151.9532, -3.4620),
+    (151.3842, -3.0354),
+    (150.6620, -2.7414),
+    (150.9399, -2.5000),
+    (151.4799, -2.7799),
+    (151.8200, -2.9999),
+    (152.2399, -3.2400),
+    (152.6400, -3.6599),
+    (151.3013, -5.8407),
+    (150.7544, -6.0837),
+    (150.2411, -6.3177),
+    (149.7099, -6.3165),
+    (148.8900, -6.0260),
+    (148.3189, -5.7471),
+    (148.4018, -5.4377),
+    (149.2984, -5.5837),
+    (149.8455, -5.5055),
+    (149.9962, -5.0261),
+    (150.1397, -5.0013),
+    (150.2369, -5.5322),
+    (150.8074, -5.4558),
+    (151.0896, -5.1136),
+    (151.6478, -4.7570),
+    (151.5378, -4.1678),
+    (152.1367, -4.1487),
+    (152.3387, -4.3129),
+    (152.3186, -4.8676),
+    (151.9827, -5.4780),
+    (151.4591, -5.5602),
+    (151.3013, -5.8407),
+    (162.1190, -10.4827),
+    (162.3986, -10.8263),
+    (161.7000, -10.8200),
+    (161.3197, -10.2047),
+    (161.9173, -10.4466),
+    (162.1190, -10.4827),
+    (161.6799, -9.5999),
+    (161.5293, -9.7843),
+    (160.7882, -8.9175),
+    (160.5799, -8.3200),
+    (160.9200, -8.3200),
+    (161.2800, -9.1200),
+    (161.6799, -9.5999),
+    (160.8522, -9.8729),
+    (160.4625, -9.8952),
+    (159.8494, -9.7940),
+    (159.6400, -9.6399),
+    (159.7029, -9.2429),
+    (160.3629, -9.4003),
+    (160.6885, -9.6101),
+    (160.8522, -9.8729),
+    (159.6400, -8.0200),
+    (159.8750, -8.3373),
+    (159.9174, -8.5382),
+    (159.1336, -8.1141),
+    (158.5861, -7.7548),
+    (158.2111, -7.4218),
+    (158.3599, -7.3200),
+    (158.8200, -7.5600),
+    (159.6400, -8.0200),
+    (157.1400, -7.0216),
+    (157.5384, -7.3478),
+    (157.3394, -7.4047),
+    (156.9020, -7.1768),
+    (156.4913, -6.7659),
+    (156.5428, -6.5993),
+    (157.1400, -7.0216),
+    (154.7599, -5.3399),
+    (155.0629, -5.5667),
+    (155.5477, -6.2006),
+    (156.0199, -6.5400),
+    (155.8800, -6.8199),
+    (155.5999, -6.9199),
+    (155.1669, -6.5359),
+    (154.7291, -5.9007),
+    (154.5141, -5.1391),
+    (154.6525, -5.0423),
+    (154.7599, -5.3399),
+    (176.8858, -40.0659),
+    (176.5080, -40.6047),
+    (176.0124, -41.2896),
+    (175.2395, -41.6883),
+    (175.0678, -41.4258),
+    (174.6509, -41.2818),
+    (175.2276, -40.4592),
+    (174.9001, -39.9088),
+    (173.8240, -39.5088),
+    (173.8522, -39.1466),
+    (174.5748, -38.7976),
+    (174.7434, -38.0278),
+    (174.6969, -37.3811),
+    (174.2920, -36.7110),
+    (174.3190, -36.5348),
+    (173.8409, -36.1219),
+    (173.0541, -35.2371),
+    (172.6360, -34.5291),
+    (173.0070, -34.4506),
+    (173.5512, -35.0061),
+    (174.3293, -35.2654),
+    (174.6120, -36.1563),
+    (175.3366, -37.2090),
+    (175.3575, -36.5261),
+    (175.8088, -36.7989),
+    (175.9584, -37.5553),
+    (176.7631, -37.8812),
+    (177.4388, -37.9612),
+    (178.0103, -37.5798),
+    (178.5170, -37.6953),
+    (178.2747, -38.5828),
+    (177.9704, -39.1663),
+    (177.2069, -39.1457),
+    (176.9399, -39.4497),
+    (177.0329, -39.8799),
+    (176.8858, -40.0659),
+    (169.6678, -43.5553),
+    (170.5249, -43.0316),
+    (171.1250, -42.5127),
+    (171.5697, -41.7674),
+    (171.9487, -41.5144),
+    (172.0972, -40.9561),
+    (172.7985, -40.4939),
+    (173.0203, -40.9190),
+    (173.2472, -41.3319),
+    (173.9584, -40.9267),
+    (174.2475, -41.3491),
+    (174.2485, -41.7700),
+    (173.8764, -42.2331),
+    (173.2227, -42.9700),
+    (172.7112, -43.3722),
+    (173.0801, -43.8533),
+    (172.3085, -43.8656),
+    (171.4529, -44.2424),
+    (171.1851, -44.8971),
+    (170.6166, -45.9089),
+    (169.8314, -46.3557),
+    (169.3323, -46.6412),
+    (168.4113, -46.6199),
+    (167.7637, -46.2901),
+    (166.6768, -46.2199),
+    (166.5091, -45.8527),
+    (167.0463, -45.1109),
+    (168.3037, -44.1239),
+    (168.9494, -43.9358),
+    (169.6678, -43.5553),
+    (147.6892, -40.8082),
+    (148.2890, -40.8754),
+    (148.3598, -42.0623),
+    (148.0173, -42.4070),
+    (147.9140, -43.2115),
+    (147.5645, -42.9376),
+    (146.8703, -43.6345),
+    (146.6633, -43.5808),
+    (146.0483, -43.5497),
+    (145.4319, -42.6937),
+    (145.2950, -42.0336),
+    (144.7180, -41.1625),
+    (144.7437, -40.7039),
+    (145.3979, -40.7925),
+    (146.3641, -41.1376),
+    (146.9085, -41.0005),
+    (147.6892, -40.8082),
+    (126.1487, -32.2159),
+    (125.0886, -32.7287),
+    (124.2216, -32.9594),
+    (124.0289, -33.4838),
+    (123.6596, -33.8901),
+    (122.8110, -33.9144),
+    (122.1830, -34.0034),
+    (121.2991, -33.8210),
+    (120.5802, -33.9301),
+    (119.8936, -33.9760),
+    (119.2988, -34.5093),
+    (119.0073, -34.4641),
+    (118.5057, -34.7468),
+    (118.0249, -35.0647),
+    (117.2955, -35.0254),
+    (116.6251, -35.0250),
+    (115.5643, -34.3864),
+    (115.0268, -34.1965),
+    (115.0486, -33.6234),
+    (115.5451, -33.4872),
+    (115.7146, -33.2595),
+    (115.6793, -32.9003),
+    (115.8016, -32.2050),
+    (115.6896, -31.6124),
+    (115.1609, -30.6015),
+    (114.9970, -30.0307),
+    (115.0400, -29.4610),
+    (114.6419, -28.8102),
+    (114.6164, -28.5163),
+    (114.1735, -28.1180),
+    (114.0488, -27.3347),
+    (113.4774, -26.5431),
+    (113.3389, -26.1165),
+    (113.7783, -26.5490),
+    (113.4409, -25.6212),
+    (113.9369, -25.9112),
+    (114.2328, -26.2984),
+    (114.2161, -25.7862),
+    (113.7212, -24.9989),
+    (113.6253, -24.6839),
+    (113.3935, -24.3847),
+    (113.5020, -23.8063),
+    (113.7069, -23.5602),
+    (113.8434, -23.0599),
+    (113.7365, -22.4754),
+    (114.1497, -21.7558),
+    (114.2253, -22.5174),
+    (114.6477, -21.8295),
+    (115.4601, -21.4951),
+    (115.9473, -21.0686),
+    (116.7116, -20.7016),
+    (117.1663, -20.6235),
+    (117.4415, -20.7468),
+    (118.2295, -20.3742),
+    (118.8360, -20.2633),
+    (118.9878, -20.0442),
+    (119.2524, -19.9529),
+    (119.8052, -19.9765),
+    (120.8562, -19.6837),
+    (121.3998, -19.2397),
+    (121.6550, -18.7053),
+    (122.2416, -18.1976),
+    (122.2866, -17.7986),
+    (122.3127, -17.2549),
+    (123.0125, -16.4051),
+    (123.4337, -17.2685),
+    (123.8593, -17.0690),
+    (123.5032, -16.5965),
+    (123.8170, -16.1113),
+    (124.2582, -16.3279),
+    (124.3797, -15.5670),
+    (124.9261, -15.0751),
+    (125.1672, -14.6803),
+    (125.6700, -14.5100),
+    (125.6857, -14.2306),
+    (126.1251, -14.3473),
+    (126.1428, -14.0959),
+    (126.5825, -13.9527),
+    (127.0658, -13.8179),
+    (127.8046, -14.2769),
+    (128.3596, -14.8691),
+    (128.9855, -14.8759),
+    (129.6214, -14.9697),
+    (129.4096, -14.4206),
+    (129.8886, -13.6187),
+    (130.3394, -13.3573),
+    (130.1835, -13.1075),
+    (130.6177, -12.5363),
+    (131.2234, -12.1836),
+    (131.7350, -12.3024),
+    (132.5752, -12.1140),
+    (132.5572, -11.6030),
+    (131.8246, -11.2737),
+    (132.3572, -11.1285),
+    (133.0195, -11.3764),
+    (133.5508, -11.7865),
+    (134.3930, -12.0423),
+    (134.6786, -11.9411),
+    (135.2984, -12.2486),
+    (135.8826, -11.9622),
+    (136.2583, -12.0493),
+    (136.4924, -11.8572),
+    (136.9516, -12.3519),
+    (136.6851, -12.8872),
+    (136.3054, -13.2912),
+    (135.9617, -13.3245),
+    (136.0776, -13.7242),
+    (135.7838, -14.2239),
+    (135.4286, -14.7154),
+    (135.5001, -14.9977),
+    (136.2951, -15.5502),
+    (137.0653, -15.8707),
+    (137.5804, -16.2150),
+    (138.3032, -16.8076),
+    (138.5851, -16.8066),
+    (139.1085, -17.0626),
+    (139.2605, -17.3716),
+    (140.2151, -17.7108),
+    (140.8754, -17.3690),
+    (141.0711, -16.8320),
+    (141.2740, -16.3888),
+    (141.3982, -15.8405),
+    (141.7021, -15.0449),
+    (141.5633, -14.5613),
+    (141.6355, -14.2703),
+    (141.5198, -13.6980),
+    (141.6509, -12.9446),
+    (141.8426, -12.7415),
+    (141.6869, -12.4076),
+    (141.9286, -11.8774),
+    (142.1184, -11.3280),
+    (142.1437, -11.0427),
+    (142.5152, -10.6681),
+    (142.7973, -11.1573),
+    (142.8667, -11.7847),
+    (143.1159, -11.9056),
+    (143.1586, -12.3256),
+    (143.5221, -12.8343),
+    (143.5971, -13.4004),
+    (143.5618, -13.7636),
+    (143.9220, -14.5483),
+    (144.5637, -14.1711),
+    (144.8948, -14.5944),
+    (145.3747, -14.9849),
+    (145.2719, -15.4282),
+    (145.4852, -16.2856),
+    (145.6369, -16.7849),
+    (145.8888, -16.9069),
+    (146.1603, -17.7616),
+    (146.0636, -18.2800),
+    (146.3874, -18.9582),
+    (147.4710, -19.4807),
+    (148.1776, -19.9559),
+    (148.8484, -20.3912),
+    (148.7174, -20.6334),
+    (149.2894, -21.2605),
+    (149.6783, -22.3425),
+    (150.0773, -22.1227),
+    (150.4829, -22.5561),
+    (150.7272, -22.4023),
+    (150.8995, -23.4622),
+    (151.6091, -24.0762),
+    (152.0735, -24.4578),
+    (152.8551, -25.2675),
+    (153.1361, -26.0711),
+    (153.1619, -26.6413),
+    (153.0929, -27.2602),
+    (153.5694, -28.1100),
+    (153.5121, -28.9950),
+    (153.3390, -29.4582),
+    (153.0692, -30.3502),
+    (153.0895, -30.9236),
+    (152.8915, -31.6404),
+    (152.4500, -32.5500),
+    (151.7091, -33.0413),
+    (151.3439, -33.8160),
+    (151.0105, -34.3103),
+    (150.7141, -35.1734),
+    (150.3282, -35.6718),
+    (150.0752, -36.4202),
+    (149.9461, -37.1090),
+    (149.9972, -37.4252),
+    (149.4238, -37.7726),
+    (148.3046, -37.8090),
+    (147.3817, -38.2192),
+    (146.9221, -38.6065),
+    (146.3179, -39.0357),
+    (145.4896, -38.5937),
+    (144.8769, -38.4174),
+    (145.0322, -37.8961),
+    (144.4856, -38.0853),
+    (143.6099, -38.8094),
+    (142.7454, -38.5382),
+    (142.1783, -38.3800),
+    (141.6065, -38.3085),
+    (140.6385, -38.0193),
+    (139.9921, -37.4029),
+    (139.8065, -36.6436),
+    (139.5741, -36.1383),
+    (139.0828, -35.7327),
+    (138.1207, -35.6122),
+    (138.4494, -35.1272),
+    (138.2075, -34.3847),
+    (137.7191, -35.0768),
+    (136.8294, -35.2605),
+    (137.3523, -34.7073),
+    (137.5038, -34.1302),
+    (137.8901, -33.6404),
+    (137.8103, -32.9000),
+    (136.9968, -33.7527),
+    (136.3720, -34.0947),
+    (135.9890, -34.8901),
+    (135.2082, -34.4786),
+    (135.2392, -33.9479),
+    (134.6134, -33.2227),
+    (134.0859, -32.8480),
+    (134.2739, -32.6172),
+    (132.9907, -32.0112),
+    (132.2880, -31.9826),
+    (131.3263, -31.4958),
+    (129.5357, -31.5904),
+    (128.2409, -31.9484),
+    (127.1028, -32.2822),
+    (126.1487, -32.2159),
+    (81.7879, 7.5230),
+    (81.6373, 6.4817),
+    (81.2180, 6.1971),
+    (80.3483, 5.9683),
+    (79.8724, 6.7634),
+    (79.6951, 8.2008),
+    (80.1478, 9.8240),
+    (80.8388, 9.2684),
+    (81.3043, 8.5642),
+    (81.7879, 7.5230),
+    (129.3709, -2.8021),
+    (130.4713, -3.0937),
+    (130.8348, -3.8584),
+    (129.9905, -3.4463),
+    (129.1552, -3.3626),
+    (128.5906, -3.4286),
+    (127.8988, -3.3934),
+    (128.1358, -2.8436),
+    (129.3709, -2.8021),
+    (126.8749, -3.7909),
+    (126.1838, -3.6073),
+    (125.9890, -3.1772),
+    (127.0006, -3.1293),
+    (127.2492, -3.4590),
+    (126.8749, -3.7909),
+    (127.9323, 2.1745),
+    (128.0041, 1.6285),
+    (128.5945, 1.5408),
+    (128.6882, 1.1323),
+    (128.6359, 0.2584),
+    (128.1201, 0.3564),
+    (127.9680, -0.2520),
+    (128.3799, -0.7800),
+    (128.1000, -0.8999),
+    (127.6964, -0.2665),
+    (127.3994, 1.0117),
+    (127.6005, 1.8106),
+    (127.9323, 2.1745),
+    (122.9275, 0.8751),
+    (124.0775, 0.9171),
+    (125.0659, 1.6432),
+    (125.2405, 1.4198),
+    (124.4370, 0.4278),
+    (123.6855, 0.2355),
+    (122.7230, 0.4311),
+    (121.0567, 0.3812),
+    (120.1830, 0.2372),
+    (120.0408, -0.5196),
+    (120.9359, -1.4089),
+    (121.4758, -0.9559),
+    (123.3405, -0.6156),
+    (123.2583, -1.0762),
+    (122.8226, -0.9309),
+    (122.3885, -1.5168),
+    (121.5082, -1.9044),
+    (122.4545, -3.1860),
+    (122.2718, -3.5295),
+    (123.1709, -4.6836),
+    (123.1623, -5.3406),
+    (122.6285, -5.6345),
+    (122.2363, -5.2829),
+    (122.7195, -4.4641),
+    (121.7382, -4.8513),
+    (121.4894, -4.5745),
+    (121.6191, -4.1884),
+    (120.8981, -3.6021),
+    (120.9723, -2.6276),
+    (120.3054, -2.9316),
+    (120.3900, -4.0975),
+    (120.4307, -5.5282),
+    (119.7965, -5.6734),
+    (119.3669, -5.3798),
+    (119.6536, -4.4594),
+    (119.4988, -3.4944),
+    (119.0783, -3.4870),
+    (118.7677, -2.8019),
+    (119.1809, -2.1471),
+    (119.3233, -1.3531),
+    (119.8259, 0.1542),
+    (120.0357, 0.5664),
+    (120.8857, 1.3092),
+    (121.6668, 1.0139),
+    (122.9275, 0.8751),
+    (120.2950, -10.2586),
+    (118.9678, -9.5579),
+    (119.9003, -9.3613),
+    (120.4257, -9.6659),
+    (120.7755, -9.9696),
+    (120.7156, -10.2395),
+    (120.2950, -10.2586),
+    (121.3416, -8.5367),
+    (122.0073, -8.4606),
+    (122.9035, -8.0942),
+    (122.7569, -8.6498),
+    (121.2544, -8.9336),
+    (119.9243, -8.8104),
+    (119.9209, -8.4448),
+    (120.7150, -8.2369),
+    (121.3416, -8.5367),
+    (118.2606, -8.3623),
+    (118.8784, -8.2806),
+    (119.1265, -8.7058),
+    (117.9704, -8.9066),
+    (117.2777, -9.0408),
+    (116.7401, -9.0328),
+    (117.0837, -8.4571),
+    (117.6320, -8.4493),
+    (117.9000, -8.0956),
+    (118.2606, -8.3623),
+    (108.4868, -6.4219),
+    (108.6234, -6.7776),
+    (110.5392, -6.8773),
+    (110.7595, -6.4651),
+    (112.6148, -6.9460),
+    (112.9787, -7.5942),
+    (114.4789, -7.7765),
+    (115.7055, -8.3708),
+    (114.5645, -8.7518),
+    (113.4647, -8.3489),
+    (112.5596, -8.3761),
+    (111.5220, -8.3021),
+    (110.5861, -8.1226),
+    (109.4276, -7.7406),
+    (108.6936, -7.6416),
+    (108.2777, -7.7666),
+    (106.4541, -7.3548),
+    (106.2806, -6.9248),
+    (105.3654, -6.8514),
+    (106.0516, -5.8959),
+    (107.2650, -5.9549),
+    (108.0720, -6.3457),
+    (108.4868, -6.4219),
+    (104.3699, -1.0848),
+    (104.5394, -1.7823),
+    (104.8878, -2.3404),
+    (105.6221, -2.4288),
+    (106.1085, -3.0617),
+    (105.8574, -4.3055),
+    (105.8176, -5.8523),
+    (104.7103, -5.8732),
+    (103.8682, -5.0373),
+    (102.5842, -4.2202),
+    (102.1561, -3.6141),
+    (101.3991, -2.7997),
+    (100.9025, -2.0502),
+    (100.1419, -0.6503),
+    (99.2637, 0.1831),
+    (98.9700, 1.0428),
+    (98.6013, 1.8235),
+    (97.6995, 2.4531),
+    (97.1769, 3.3087),
+    (96.4240, 3.8688),
+    (95.3808, 4.9707),
+    (95.2930, 5.4798),
+    (95.9368, 5.4395),
+    (97.4848, 5.2463),
+    (98.3691, 4.2683),
+    (99.1425, 3.5903),
+    (99.6939, 3.1743),
+    (100.6414, 2.0993),
+    (101.6580, 2.0836),
+    (102.4982, 1.3987),
+    (103.0768, 0.5613),
+    (103.8383, 0.1045),
+    (103.4376, -0.7119),
+    (104.0107, -1.0592),
+    (104.3699, -1.0848),
+    (120.8338, 12.7044),
+    (120.3234, 13.4664),
+    (121.1801, 13.4296),
+    (121.5273, 13.0695),
+    (121.2621, 12.2055),
+    (120.8338, 12.7044),
+    (122.5860, 9.9810),
+    (122.8370, 10.2611),
+    (122.9474, 10.8818),
+    (123.4988, 10.9406),
+    (123.3377, 10.2673),
+    (124.0779, 11.2327),
+    (123.9824, 10.2787),
+    (123.6230, 9.9500),
+    (123.3099, 9.3182),
+    (122.9958, 9.0221),
+    (122.3800, 9.7133),
+    (122.5860, 9.9810),
+    (126.3768, 8.4147),
+    (126.4785, 7.7503),
+    (126.5374, 7.1894),
+    (126.1967, 6.2742),
+    (125.8314, 7.2937),
+    (125.3638, 6.7864),
+    (125.6831, 6.0496),
+    (125.3965, 5.5810),
+    (124.2197, 6.1613),
+    (123.9387, 6.8851),
+    (124.2436, 7.3606),
+    (123.6101, 7.8335),
+    (123.2960, 7.4188),
+    (122.8255, 7.4573),
+    (122.0854, 6.8994),
+    (121.9199, 7.1921),
+    (122.3123, 8.0349),
+    (122.9423, 8.3162),
+    (123.4876, 8.6930),
+    (123.8411, 8.2403),
+    (124.6014, 8.5141),
+    (124.7646, 8.9604),
+    (125.4713, 8.9869),
+    (125.4121, 9.7603),
+    (126.2227, 9.2860),
+    (126.3066, 8.7824),
+    (126.3768, 8.4147),
+    (109.4752, 18.1977),
+    (108.6552, 18.5076),
+    (108.6262, 19.3678),
+    (109.1190, 19.8210),
+    (110.2115, 20.1012),
+    (110.7865, 20.0775),
+    (111.0100, 19.6959),
+    (110.5706, 19.2558),
+    (110.3391, 18.6783),
+    (109.4752, 18.1977),
+    (121.7778, 24.3942),
+    (121.1756, 22.7908),
+    (120.7470, 21.9705),
+    (120.2200, 22.8148),
+    (120.1061, 23.5562),
+    (120.6946, 24.5384),
+    (121.4950, 25.2954),
+    (121.9512, 24.9975),
+    (121.7778, 24.3942),
+    (141.8846, 39.1808),
+    (140.9594, 38.1740),
+    (140.9763, 37.1420),
+    (140.5997, 36.3439),
+    (140.7740, 35.8428),
+    (140.2532, 35.1381),
+    (138.9755, 34.6676),
+    (137.2175, 34.6062),
+    (135.7929, 33.4648),
+    (135.1209, 33.8490),
+    (135.0794, 34.5965),
+    (133.3403, 34.3759),
+    (132.1567, 33.9049),
+    (130.9861, 33.8857),
+    (132.0000, 33.1499),
+    (131.3327, 31.4503),
+    (130.6863, 31.0295),
+    (130.2024, 31.4182),
+    (130.4476, 32.3194),
+    (129.8146, 32.6103),
+    (129.4084, 33.2960),
+    (130.3539, 33.6041),
+    (130.8784, 34.2327),
+    (131.8842, 34.7497),
+    (132.6176, 35.4333),
+    (134.6083, 35.7316),
+    (135.6775, 35.5271),
+    (136.7238, 37.3049),
+    (137.3906, 36.8273),
+    (138.8576, 37.8274),
+    (139.4264, 38.2159),
+    (140.0547, 39.4388),
+    (139.8833, 40.5633),
+    (140.3057, 41.1950),
+    (141.3689, 41.3785),
+    (141.9142, 39.9916),
+    (141.8846, 39.1808),
+    (144.6134, 43.9609),
+    (145.3208, 44.3847),
+    (145.5431, 43.2621),
+    (144.0596, 42.9883),
+    (143.1838, 41.9952),
+    (141.6114, 42.6787),
+    (141.0672, 41.5845),
+    (139.9551, 41.5695),
+    (139.8175, 42.5637),
+    (140.3120, 43.3332),
+    (141.3805, 43.3888),
+    (141.6719, 44.7721),
+    (141.9676, 45.5514),
+    (143.1428, 44.5103),
+    (143.9101, 44.1740),
+    (144.6134, 43.9609),
+    (8.7099, 40.8999),
+    (9.2100, 41.2099),
+    (9.8099, 40.5000),
+    (9.6695, 39.1773),
+    (9.2148, 39.2404),
+    (8.8069, 38.9066),
+    (8.4283, 39.1718),
+    (8.3882, 40.3783),
+    (8.1599, 40.9500),
+    (8.7099, 40.8999),
+    (8.7460, 42.6281),
+    (9.3900, 43.0099),
+    (9.5600, 42.1525),
+    (9.2297, 41.3800),
+    (8.7757, 41.5836),
+    (8.5442, 42.2565),
+    (8.7460, 42.6281),
+    (12.3709, 56.1114),
+    (12.6900, 55.6099),
+    (12.0899, 54.8000),
+    (11.0435, 55.3648),
+    (10.9039, 55.7799),
+    (12.3709, 56.1114),
+    (-4.2114, 58.5508),
+    (-3.0050, 58.6350),
+    (-4.0738, 57.5530),
+    (-3.0550, 57.6900),
+    (-1.9592, 57.6847),
+    (-2.2199, 56.8700),
+    (-3.1190, 55.9737),
+    (-2.0850, 55.9099),
+    (-1.1149, 54.6249),
+    (-0.4304, 54.4643),
+    (0.1849, 53.3250),
+    (0.4699, 52.9299),
+    (1.6815, 52.7395),
+    (1.5599, 52.0999),
+    (1.0505, 51.8067),
+    (1.4498, 51.2894),
+    (0.5503, 50.7657),
+    (-0.7875, 50.7749),
+    (-2.4899, 50.5000),
+    (-2.9562, 50.6968),
+    (-3.6174, 50.2283),
+    (-4.5425, 50.3418),
+    (-5.2450, 49.9599),
+    (-5.7765, 50.1596),
+    (-4.3099, 51.2100),
+    (-3.4148, 51.4260),
+    (-4.9843, 51.5934),
+    (-5.2672, 51.9914),
+    (-4.2223, 52.3013),
+    (-4.7700, 52.8400),
+    (-4.5799, 53.4950),
+    (-3.0920, 53.4044),
+    (-2.9450, 53.9849),
+    (-3.6300, 54.6150),
+    (-4.8441, 54.7909),
+    (-5.0825, 55.0616),
+    (-4.7191, 55.5084),
+    (-5.0479, 55.7839),
+    (-5.5863, 55.3111),
+    (-5.6449, 56.2750),
+    (-6.1499, 56.7850),
+    (-5.7868, 57.8188),
+    (-5.0099, 58.6300),
+    (-4.2114, 58.5508),
+    (-14.5086, 66.4558),
+    (-14.7396, 65.8087),
+    (-13.6097, 65.1266),
+    (-14.9098, 64.3640),
+    (-17.7944, 63.6787),
+    (-18.6562, 63.4963),
+    (-19.9727, 63.6436),
+    (-22.7629, 63.9601),
+    (-21.7784, 64.4021),
+    (-23.9550, 64.8911),
+    (-22.1844, 65.0849),
+    (-22.2274, 65.3785),
+    (-24.3261, 65.6111),
+    (-23.6505, 66.2625),
+    (-22.1349, 66.4104),
+    (-20.5762, 65.7321),
+    (-19.0568, 66.2766),
+    (-17.7986, 65.9938),
+    (-16.1678, 66.5268),
+    (-14.5086, 66.4558),
+    (142.9146, 53.7045),
+    (143.2608, 52.7407),
+    (143.2352, 51.7566),
+    (143.6480, 50.7476),
+    (144.6541, 48.9763),
+    (143.1739, 49.3065),
+    (142.5586, 47.8615),
+    (143.5334, 46.8367),
+    (143.5052, 46.1379),
+    (142.7477, 46.7407),
+    (142.0920, 45.9667),
+    (141.9069, 46.8059),
+    (142.0184, 47.7801),
+    (141.9044, 48.8591),
+    (142.1358, 49.6151),
+    (142.1799, 50.9523),
+    (141.5940, 51.9354),
+    (141.6825, 53.3019),
+    (142.6069, 53.7621),
+    (142.2097, 54.2254),
+    (142.6547, 54.3658),
+    (142.9146, 53.7045),
+    (118.5045, 9.3163),
+    (117.1742, 8.3674),
+    (117.6644, 9.0668),
+    (118.3869, 9.6844),
+    (118.9873, 10.3762),
+    (119.5114, 11.3696),
+    (119.6896, 10.5542),
+    (119.0294, 10.0036),
+    (118.5045, 9.3163),
+    (122.3369, 18.2248),
+    (122.1742, 17.8102),
+    (122.5156, 17.0935),
+    (122.2523, 16.2624),
+    (121.6627, 15.9310),
+    (121.5050, 15.1248),
+    (121.7288, 14.3283),
+    (122.2589, 14.2182),
+    (122.7012, 14.3365),
+    (123.9502, 13.7821),
+    (123.8551, 13.2377),
+    (124.1812, 12.9975),
+    (124.0774, 12.5366),
+    (123.2980, 13.0275),
+    (122.9286, 13.5529),
+    (122.6713, 13.1858),
+    (122.0346, 13.7844),
+    (121.1263, 13.6366),
+    (120.6286, 13.8576),
+    (120.6793, 14.2710),
+    (120.9918, 14.5253),
+    (120.6933, 14.7566),
+    (120.5641, 14.3962),
+    (120.0704, 14.9708),
+    (119.9209, 15.4063),
+    (119.8837, 16.3637),
+    (120.2864, 16.0346),
+    (120.3900, 17.5990),
+    (120.7158, 18.5052),
+    (121.3213, 18.5040),
+    (121.9376, 18.2185),
+    (122.2460, 18.4789),
+    (122.3369, 18.2248),
+    (122.0383, 11.4158),
+    (121.8835, 11.8917),
+    (122.4838, 11.5822),
+    (123.1202, 11.5836),
+    (123.1008, 11.1659),
+    (122.6377, 10.7413),
+    (122.0026, 10.4410),
+    (121.9673, 10.9056),
+    (122.0383, 11.4158),
+    (125.5025, 12.1626),
+    (125.7834, 11.0461),
+    (125.0118, 11.3114),
+    (125.0327, 10.9758),
+    (125.2774, 10.3587),
+    (124.8018, 10.1346),
+    (124.7601, 10.8379),
+    (124.4591, 10.8899),
+    (124.3025, 11.4953),
+    (124.8910, 11.4155),
+    (124.8779, 11.7941),
+    (124.2667, 12.5577),
+    (125.2271, 12.5357),
+    (125.5025, 12.1626),
+    (-77.3533, 8.6705),
+    (-76.8366, 8.6387),
+    (-76.0863, 9.3368),
+    (-75.6746, 9.4432),
+    (-75.6647, 9.7740),
+    (-75.4804, 10.6189),
+    (-74.9068, 11.0830),
+    (-74.2767, 11.1020),
+    (-74.1972, 11.3104),
+    (-73.4147, 11.2270),
+    (-72.6278, 11.7319),
+    (-72.2381, 11.9555),
+    (-71.7540, 12.4373),
+    (-71.3998, 12.3760),
+    (-71.1374, 12.1129),
+    (-71.3315, 11.7762),
+    (-71.3600, 11.5399),
+    (-71.9470, 11.4232),
+    (-71.6208, 10.9694),
+    (-71.6330, 10.4464),
+    (-72.0741, 9.8656),
+    (-71.6956, 9.0722),
+    (-71.2645, 9.1372),
+    (-71.0399, 9.8599),
+    (-71.3500, 10.2119),
+    (-71.4006, 10.9689),
+    (-70.1552, 11.3754),
+    (-70.2938, 11.8468),
+    (-69.9432, 12.1623),
+    (-69.5843, 11.4596),
+    (-68.8829, 11.4433),
+    (-68.2332, 10.8857),
+    (-68.1941, 10.5546),
+    (-67.2962, 10.5458),
+    (-66.2278, 10.6486),
+    (-65.6552, 10.2007),
+    (-64.8904, 10.0772),
+    (-64.3294, 10.3895),
+    (-64.3180, 10.6414),
+    (-63.0793, 10.7017),
+    (-61.8809, 10.7156),
+    (-62.7301, 10.4202),
+    (-62.3885, 9.9482),
+    (-61.5887, 9.8730),
+    (-60.8305, 9.3813),
+    (-60.6712, 8.5801),
+    (-60.1500, 8.6027),
+    (-59.7582, 8.3670),
+    (-59.1016, 7.9992),
+    (-58.4829, 7.3476),
+    (-58.4548, 6.8327),
+    (-58.0781, 6.8090),
+    (-57.5422, 6.3212),
+    (-57.1474, 5.9731),
+    (-55.9493, 5.7728),
+    (-55.8417, 5.9531),
+    (-55.0332, 6.0252),
+    (-53.9580, 5.7565),
+    (-53.6184, 5.6465),
+    (-52.8821, 5.4098),
+    (-51.8233, 4.5657),
+    (-51.6577, 4.1562),
+    (-51.2999, 4.1200),
+    (-51.0697, 3.6503),
+    (-50.5088, 1.9015),
+    (-49.9740, 1.7364),
+    (-49.9471, 1.0461),
+    (-50.6992, 0.2229),
+    (-50.3882, -0.0784),
+    (-48.6205, -0.2354),
+    (-48.5844, -1.2378),
+    (-47.8249, -0.5816),
+    (-46.5665, -0.9410),
+    (-44.9057, -1.5517),
+    (-44.4176, -2.1377),
+    (-44.5815, -2.6913),
+    (-43.4187, -2.3831),
+    (-41.4726, -2.9120),
+    (-39.9786, -2.8730),
+    (-38.5003, -3.7006),
+    (-37.2232, -4.8209),
+    (-36.4529, -5.1094),
+    (-35.5977, -5.1495),
+    (-35.2353, -5.4649),
+    (-34.8960, -6.7381),
+    (-34.7299, -7.3432),
+    (-35.1282, -8.9964),
+    (-35.6369, -9.6492),
+    (-37.0465, -11.0407),
+    (-37.6836, -12.1711),
+    (-38.4238, -13.0381),
+    (-38.6738, -13.0576),
+    (-38.9532, -13.7933),
+    (-38.8822, -15.6670),
+    (-39.1610, -17.2084),
+    (-39.2673, -17.8677),
+    (-39.5835, -18.2622),
+    (-39.7608, -19.5991),
+    (-40.7747, -20.9045),
+    (-40.9447, -21.9373),
+    (-41.7541, -22.3706),
+    (-41.9882, -22.9700),
+    (-43.0747, -22.9676),
+    (-44.6478, -23.3519),
+    (-45.3521, -23.7968),
+    (-46.4720, -24.0889),
+    (-47.6489, -24.8851),
+    (-48.4954, -25.8770),
+    (-48.6410, -26.6236),
+    (-48.4747, -27.1759),
+    (-48.6615, -28.1861),
+    (-48.8884, -28.6741),
+    (-49.5873, -29.2244),
+    (-50.6968, -30.9844),
+    (-51.5762, -31.7776),
+    (-52.2560, -32.2453),
+    (-52.7120, -33.1965),
+    (-53.3736, -33.7683),
+    (-53.8064, -34.3968),
+    (-54.9358, -34.9526),
+    (-55.6740, -34.7526),
+    (-56.2152, -34.8598),
+    (-57.1396, -34.4304),
+    (-57.8178, -34.4625),
+    (-58.4270, -33.9094),
+    (-58.4954, -34.4314),
+    (-57.2258, -35.2880),
+    (-57.3623, -35.9773),
+    (-56.7374, -36.4131),
+    (-56.7882, -36.9015),
+    (-57.7491, -38.1838),
+    (-59.2318, -38.7201),
+    (-61.2374, -38.9284),
+    (-62.3359, -38.8277),
+    (-62.1257, -39.4241),
+    (-62.3305, -40.1725),
+    (-62.1459, -40.6768),
+    (-62.7458, -41.0287),
+    (-63.7704, -41.1667),
+    (-64.7320, -40.8026),
+    (-65.1180, -41.0643),
+    (-64.9785, -42.0580),
+    (-64.3034, -42.3590),
+    (-63.7559, -42.0436),
+    (-63.4580, -42.5631),
+    (-64.3788, -42.8735),
+    (-65.1818, -43.4953),
+    (-65.3288, -44.5013),
+    (-65.5652, -45.0367),
+    (-66.5099, -45.0396),
+    (-67.2937, -45.5518),
+    (-67.5805, -46.3017),
+    (-66.5970, -47.0338),
+    (-65.6410, -47.2361),
+    (-65.9850, -48.1332),
+    (-67.1661, -48.6973),
+    (-67.8160, -49.8696),
+    (-68.7287, -50.2641),
+    (-69.1385, -50.7325),
+    (-68.8155, -51.7711),
+    (-68.1499, -52.3499),
+    (-68.5715, -52.2994),
+    (-69.4612, -52.2919),
+    (-69.9427, -52.5379),
+    (-70.8451, -52.8991),
+    (-71.0063, -53.8332),
+    (-71.4297, -53.8564),
+    (-72.5579, -53.5314),
+    (-73.7027, -52.8350),
+    (-74.9467, -52.2627),
+    (-75.2600, -51.6293),
+    (-74.9766, -51.0433),
+    (-75.4797, -50.3783),
+    (-75.6080, -48.6737),
+    (-75.1827, -47.7119),
+    (-74.1265, -46.9392),
+    (-75.6443, -46.6476),
+    (-74.6921, -45.7639),
+    (-74.3517, -44.1030),
+    (-73.2403, -44.4549),
+    (-72.7178, -42.3833),
+    (-73.3888, -42.1175),
+    (-73.7013, -43.3657),
+    (-74.3319, -43.2249),
+    (-74.0179, -41.7948),
+    (-73.6770, -39.9422),
+    (-73.2175, -39.2586),
+    (-73.5055, -38.2828),
+    (-73.5880, -37.1562),
+    (-73.1667, -37.1237),
+    (-72.5531, -35.5088),
+    (-71.8617, -33.9090),
+    (-71.4384, -32.4188),
+    (-71.6687, -30.9206),
+    (-71.3700, -30.0956),
+    (-71.4898, -28.8614),
+    (-70.9051, -27.6403),
+    (-70.7249, -25.7059),
+    (-70.4039, -23.6289),
+    (-70.0912, -21.3933),
+    (-70.1644, -19.7564),
+    (-70.3725, -18.3479),
+    (-71.3752, -17.7737),
+    (-71.4620, -17.3634),
+    (-73.4445, -16.3593),
+    (-75.2378, -15.2656),
+    (-76.0092, -14.6492),
+    (-76.4234, -13.8231),
+    (-76.2592, -13.5350),
+    (-77.1061, -12.2227),
+    (-78.0921, -10.3777),
+    (-79.0369, -8.3865),
+    (-79.4459, -7.9308),
+    (-79.7605, -7.1943),
+    (-80.5374, -6.5416),
+    (-81.2499, -6.1368),
+    (-80.9263, -5.6905),
+    (-81.4109, -4.7367),
+    (-81.0996, -4.0363),
+    (-80.3025, -3.4048),
+    (-79.7702, -2.6575),
+    (-79.9865, -2.2207),
+    (-80.3687, -2.6851),
+    (-80.9677, -2.2469),
+    (-80.7648, -1.9650),
+    (-80.9336, -1.0574),
+    (-80.5833, -0.9066),
+    (-80.3993, -0.2837),
+    (-80.0208, 0.3603),
+    (-80.0906, 0.7684),
+    (-79.5427, 0.9829),
+    (-78.8552, 1.3809),
+    (-78.9909, 1.6913),
+    (-78.6178, 1.7664),
+    (-78.6621, 2.2673),
+    (-78.4276, 2.6295),
+    (-77.9315, 2.6966),
+    (-77.5104, 3.3250),
+    (-77.1276, 3.8496),
+    (-77.4962, 4.0876),
+    (-77.3076, 4.6679),
+    (-77.5332, 5.5828),
+    (-77.3188, 5.8453),
+    (-77.4766, 6.6911),
+    (-77.8815, 7.2237),
+    (-74.6625, -52.8374),
+    (-73.8380, -53.0474),
+    (-72.4341, -53.7153),
+    (-71.1077, -54.0743),
+    (-70.5917, -53.6158),
+    (-70.2674, -52.9312),
+    (-69.3456, -52.5182),
+    (-68.6341, -52.6362),
+    (-68.2500, -53.1000),
+    (-67.7499, -53.8499),
+    (-66.4499, -54.4500),
+    (-65.0500, -54.7000),
+    (-65.5000, -55.1999),
+    (-66.4499, -55.2500),
+    (-66.9599, -54.8968),
+    (-67.2910, -55.3012),
+    (-68.1486, -55.6118),
+    (-68.6399, -55.5800),
+    (-69.2320, -55.4990),
+    (-69.9580, -55.1984),
+    (-71.0056, -55.0538),
+    (-72.2639, -54.4951),
+    (-73.2852, -53.9575),
+    (-74.6625, -52.8374),
+    (44.8469, 80.5898),
+    (46.7991, 80.7719),
+    (48.3184, 80.7840),
+    (48.5228, 80.5145),
+    (49.0971, 80.7539),
+    (50.0397, 80.9188),
+    (51.5229, 80.6997),
+    (51.1361, 80.5472),
+    (49.7936, 80.4154),
+    (48.8944, 80.3395),
+    (48.7549, 80.1754),
+    (47.5861, 80.0101),
+    (46.5028, 80.2472),
+    (47.0724, 80.5594),
+    (44.8469, 80.5898),
+    (53.5082, 73.7498),
+    (55.9024, 74.6274),
+    (55.6319, 75.0814),
+    (57.8686, 75.6093),
+    (61.1700, 76.2518),
+    (64.4983, 76.4390),
+    (66.2109, 76.8097),
+    (68.1570, 76.9396),
+    (68.8522, 76.5448),
+    (68.1805, 76.2336),
+    (64.6373, 75.7377),
+    (61.5835, 75.2608),
+    (58.4770, 74.3090),
+    (56.9867, 73.3330),
+    (55.4193, 72.3712),
+    (55.6228, 71.5405),
+    (57.5356, 70.7204),
+    (56.9449, 70.6327),
+    (53.6773, 70.7626),
+    (53.4120, 71.2066),
+    (51.6018, 71.4747),
+    (51.4557, 72.0148),
+    (52.4782, 72.2294),
+    (52.4441, 72.7747),
+    (54.4276, 73.6275),
+    (53.5082, 73.7498),
+    (27.4075, 80.0564),
+    (25.9246, 79.5178),
+    (23.0244, 79.4000),
+    (20.0751, 79.5668),
+    (19.8972, 79.8423),
+    (18.4622, 79.8598),
+    (17.3680, 80.3188),
+    (20.4559, 80.5981),
+    (21.9079, 80.3576),
+    (22.9192, 80.6571),
+    (25.4476, 80.4073),
+    (27.4075, 80.0564),
+    (24.7241, 77.8538),
+    (22.4903, 77.4449),
+    (20.7260, 77.6770),
+    (21.4160, 77.9350),
+    (20.8118, 78.2546),
+    (22.8842, 78.4549),
+    (23.2813, 78.0795),
+    (24.7241, 77.8538),
+    (15.1428, 79.6743),
+    (15.5225, 80.0160),
+    (16.9908, 80.0508),
+    (18.2518, 79.7017),
+    (21.5438, 78.9561),
+    (19.0273, 78.5625),
+    (18.4717, 77.8266),
+    (17.5944, 77.6379),
+    (17.1182, 76.8094),
+    (15.9131, 76.7704),
+    (13.7626, 77.3803),
+    (14.6695, 77.7356),
+    (13.1705, 78.0249),
+    (11.2222, 78.8692),
+    (10.4445, 79.6523),
+    (13.1707, 80.0104),
+    (13.7185, 79.6604),
+    (15.1428, 79.6743),
+    (-77.8815, 7.2237),
+    (-78.2149, 7.5122),
+    (-78.4291, 8.0520),
+    (-78.1820, 8.3191),
+    (-78.4354, 8.3877),
+    (-78.6221, 8.7181),
+    (-79.1203, 8.9960),
+    (-79.5578, 8.9323),
+    (-79.7605, 8.5845),
+    (-80.1644, 8.3333),
+    (-80.3826, 8.2984),
+    (-80.4806, 8.0903),
+    (-80.0036, 7.5475),
+    (-80.2766, 7.4197),
+    (-80.4211, 7.2715),
+    (-80.8864, 7.2205),
+    (-81.0595, 7.8179),
+    (-81.1897, 7.6479),
+    (-81.5195, 7.7066),
+    (-81.7213, 8.1089),
+    (-82.1314, 8.1753),
+    (-82.3909, 8.2923),
+    (-82.6054, 8.2916),
+    (-82.8200, 8.2908),
+    (-82.8509, 8.0738),
+    (-82.9657, 8.2250),
+    (-83.5084, 8.4469),
+    (-83.7114, 8.6568),
+    (-83.5963, 8.8304),
+    (-83.6326, 9.0513),
+    (-83.9098, 9.2908),
+    (-84.3034, 9.4873),
+    (-84.6476, 9.6155),
+    (-84.7133, 9.9080),
+    (-84.9756, 10.0867),
+    (-84.9113, 9.7959),
+    (-85.1109, 9.5570),
+    (-85.3394, 9.8345),
+    (-85.6607, 9.9333),
+    (-85.7974, 10.1348),
+    (-85.7917, 10.4393),
+    (-85.6593, 10.7543),
+    (-85.8005, 10.8247),
+    (-85.9417, 10.8952),
+    (-85.7125, 11.0884),
+    (-86.0584, 11.4034),
+    (-86.5258, 11.8068),
+    (-86.7459, 12.1439),
+    (-87.1675, 12.4582),
+    (-87.6684, 12.9099),
+    (-87.5574, 13.0645),
+    (-87.3923, 12.9140),
+    (-87.3166, 12.9846),
+    (-87.4894, 13.2975),
+    (-87.6412, 13.3410),
+    (-87.7931, 13.3844),
+    (-87.9041, 13.1490),
+    (-88.4833, 13.1639),
+    (-88.8432, 13.2597),
+    (-89.2567, 13.4585),
+    (-89.8123, 13.5206),
+    (-90.0955, 13.7353),
+    (-90.6086, 13.9097),
+    (-91.2324, 13.9278),
+    (-91.6897, 14.1262),
+    (-92.2277, 14.5388),
+    (-93.3594, 15.6154),
+    (-93.8751, 15.9401),
+    (-94.6916, 16.2009),
+    (-95.2502, 16.1283),
+    (-96.0533, 15.7520),
+    (-96.5574, 15.6535),
+    (-97.2635, 15.9170),
+    (-98.0130, 16.1073),
+    (-98.9476, 16.5660),
+    (-99.6973, 16.7061),
+    (-100.8294, 17.1710),
+    (-101.6660, 17.6490),
+    (-101.9185, 17.9160),
+    (-102.4781, 17.9757),
+    (-103.5009, 18.2922),
+    (-103.9175, 18.7485),
+    (-104.9920, 19.3161),
+    (-105.4930, 19.9467),
+    (-105.7313, 20.4341),
+    (-105.3977, 20.5317),
+    (-105.5006, 20.8168),
+    (-105.2707, 21.0762),
+    (-105.2658, 21.4221),
+    (-105.6031, 21.8711),
+    (-105.6934, 22.2690),
+    (-106.0287, 22.7737),
+    (-106.9099, 23.7678),
+    (-107.9154, 24.5489),
+    (-108.4019, 25.1723),
+    (-109.2601, 25.5806),
+    (-109.4440, 25.8248),
+    (-109.2916, 26.4429),
+    (-109.8014, 26.6761),
+    (-110.3917, 27.1621),
+    (-110.6410, 27.8598),
+    (-111.1789, 27.9412),
+    (-111.7596, 28.4679),
+    (-112.2282, 28.9544),
+    (-112.2718, 29.2668),
+    (-112.8095, 30.0211),
+    (-113.1638, 30.7868),
+    (-113.1486, 31.1709),
+    (-113.8718, 31.5676),
+    (-114.2057, 31.5240),
+    (-114.7764, 31.7995),
+    (-114.9366, 31.3934),
+    (-114.7712, 30.9136),
+    (-114.6738, 30.1626),
+    (-114.3309, 29.7504),
+    (-113.5888, 29.0616),
+    (-113.4240, 28.8261),
+    (-113.2719, 28.7547),
+    (-113.1400, 28.4112),
+    (-112.9622, 28.4251),
+    (-112.7615, 27.7802),
+    (-112.4579, 27.5258),
+    (-112.2449, 27.1717),
+    (-111.6164, 26.6628),
+    (-111.2846, 25.7325),
+    (-110.9878, 25.2946),
+    (-110.7100, 24.8260),
+    (-110.6550, 24.2985),
+    (-110.1728, 24.2655),
+    (-109.7718, 23.8111),
+    (-109.4091, 23.3646),
+    (-109.4333, 23.1855),
+    (-109.8542, 22.8182),
+    (-110.0313, 22.8230),
+    (-110.2950, 23.4309),
+    (-110.9495, 24.0009),
+    (-111.6705, 24.4844),
+    (-112.1820, 24.7384),
+    (-112.1489, 25.4701),
+    (-112.3007, 26.0120),
+    (-112.7772, 26.3219),
+    (-113.4646, 26.7681),
+    (-113.5967, 26.6394),
+    (-113.8489, 26.9000),
+    (-114.4657, 27.1420),
+    (-115.0551, 27.7227),
+    (-114.9822, 27.7982),
+    (-114.5703, 27.7414),
+    (-114.1993, 28.1150),
+    (-114.1620, 28.5661),
+    (-114.9318, 29.2794),
+    (-115.5186, 29.5563),
+    (-115.8873, 30.1807),
+    (-116.2583, 30.8364),
+    (-116.7215, 31.6357),
+    (-117.1277, 32.5353),
+    (-117.2959, 33.0462),
+    (-117.944, 33.6212),
+    (-118.4106, 33.7409),
+    (-118.5198, 34.0277),
+    (-119.081, 34.078),
+    (-119.4388, 34.3484),
+    (-120.3677, 34.4470),
+    (-120.6228, 34.6085),
+    (-120.7443, 35.1568),
+    (-121.7145, 36.1615),
+    (-122.5474, 37.5517),
+    (-122.5119, 37.7833),
+    (-122.9531, 38.1136),
+    (-123.7271, 38.9516),
+    (-123.8651, 39.7669),
+    (-124.3980, 40.3131),
+    (-124.1788, 41.1420),
+    (-124.2137, 41.9996),
+    (-124.5328, 42.7659),
+    (-124.1421, 43.7083),
+    (-124.0205, 44.6158),
+    (-123.8989, 45.5234),
+    (-124.0796, 46.8647),
+    (-124.3956, 47.7201),
+    (-124.6872, 48.1844),
+    (-124.5661, 48.3797),
+    (-123.12, 48.04),
+    (-122.5873, 47.0959),
+    (-122.3399, 47.3600),
+    (-122.5000, 48.1800),
+    (-122.84, 49.0),
+    (-122.9742, 49.0025),
+    (-124.9102, 49.9845),
+    (-125.6246, 50.4165),
+    (-127.4356, 50.8305),
+    (-127.9927, 51.7158),
+    (-127.8503, 52.3296),
+    (-129.1297, 52.7553),
+    (-129.3052, 53.5615),
+    (-130.5149, 54.2875),
+    (-130.5361, 54.8027),
+    (-131.0858, 55.1789),
+    (-131.9672, 55.4977),
+    (-132.2500, 56.3699),
+    (-133.5391, 57.1788),
+    (-134.0780, 58.1230),
+    (-135.0382, 58.1877),
+    (-136.6280, 58.2122),
+    (-137.8000, 58.4999),
+    (-139.8677, 59.5377),
+    (-140.8252, 59.7275),
+    (-142.5744, 60.0844),
+    (-143.9588, 59.9991),
+    (-145.9255, 60.4586),
+    (-147.1143, 60.8846),
+    (-148.2243, 60.6729),
+    (-148.0180, 59.9783),
+    (-148.5708, 59.9141),
+    (-149.7278, 59.7056),
+    (-150.6082, 59.3682),
+    (-151.7163, 59.1558),
+    (-151.8594, 59.7449),
+    (-151.4097, 60.7258),
+    (-150.3469, 61.0335),
+    (-150.6211, 61.2844),
+    (-151.8958, 60.7271),
+    (-152.5783, 60.0616),
+    (-154.0191, 59.3502),
+    (-153.2875, 58.8647),
+    (-154.2324, 58.1463),
+    (-155.3074, 57.7277),
+    (-156.3083, 57.4227),
+    (-156.5560, 56.9799),
+    (-158.1172, 56.4636),
+    (-158.4333, 55.9941),
+    (-159.6033, 55.5666),
+    (-160.2897, 55.6435),
+    (-161.2230, 55.3647),
+    (-162.2377, 55.0241),
+    (-163.0694, 54.6897),
+    (-164.7855, 54.4041),
+    (-164.9422, 54.5722),
+    (-163.8483, 55.0394),
+    (-162.8700, 55.3480),
+    (-161.8041, 55.8949),
+    (-160.5636, 56.0080),
+    (-160.0705, 56.4180),
+    (-158.6844, 57.0166),
+    (-158.4610, 57.2169),
+    (-157.7227, 57.5700),
+    (-157.5502, 58.3283),
+    (-157.0416, 58.9188),
+    (-158.1947, 58.6158),
+    (-158.5172, 58.7877),
+    (-159.0586, 58.4241),
+    (-159.7116, 58.9313),
+    (-159.9812, 58.5725),
+    (-160.3552, 59.0711),
+    (-161.3550, 58.6708),
+    (-161.9688, 58.6716),
+    (-162.0549, 59.2669),
+    (-161.8741, 59.6336),
+    (-162.5180, 59.9897),
+    (-163.8183, 59.7980),
+    (-164.6622, 60.2674),
+    (-165.3463, 60.5074),
+    (-165.3508, 61.0738),
+    (-166.1213, 61.5000),
+    (-165.7344, 62.0749),
+    (-164.9191, 62.6330),
+    (-164.5625, 63.1463),
+    (-163.7533, 63.2194),
+    (-163.0672, 63.0594),
+    (-162.2605, 63.5419),
+    (-161.5344, 63.4558),
+    (-160.7725, 63.7661),
+    (-160.9583, 64.2227),
+    (-161.5180, 64.4027),
+    (-160.7777, 64.7886),
+    (-161.3919, 64.7772),
+    (-162.4530, 64.5594),
+    (-162.7577, 64.3386),
+    (-163.5463, 64.5591),
+    (-164.9608, 64.4469),
+    (-166.4252, 64.6866),
+    (-166.8450, 65.0888),
+    (-168.1105, 65.6699),
+    (-166.7052, 66.0883),
+    (-164.4747, 66.5766),
+    (-163.6525, 66.5766),
+    (-163.7886, 66.0772),
+    (-161.6777, 66.1161),
+    (-162.4897, 66.7355),
+    (-163.7197, 67.1163),
+    (-164.4309, 67.6163),
+    (-165.3902, 68.0427),
+    (-166.7644, 68.3588),
+    (-166.2047, 68.8830),
+    (-164.4308, 68.9155),
+    (-163.1686, 69.3711),
+    (-162.9305, 69.8580),
+    (-161.9088, 70.3333),
+    (-160.9347, 70.4476),
+    (-159.0391, 70.8916),
+    (-158.1197, 70.8247),
+    (-156.5808, 71.3577),
+    (-155.0677, 71.1477),
+    (-154.3441, 70.6964),
+    (-153.9000, 70.8899),
+    (-152.2100, 70.8299),
+    (-152.2700, 70.6000),
+    (-150.7399, 70.4300),
+    (-149.7200, 70.5300),
+    (-147.6133, 70.2140),
+    (-145.6899, 70.1200),
+    (-144.9200, 69.9899),
+    (-143.5894, 70.1525),
+    (-142.0725, 69.8519),
+    (-140.9859, 69.7119),
+    (-139.1205, 69.4710),
+    (-137.5463, 68.9900),
+    (-136.5035, 68.8980),
+    (-135.6257, 69.3151),
+    (-134.4146, 69.6274),
+    (-132.9292, 69.5053),
+    (-131.4313, 69.9445),
+    (-129.7947, 70.1937),
+    (-129.1077, 69.7792),
+    (-128.3615, 70.0128),
+    (-128.1381, 70.4838),
+    (-127.4471, 70.3772),
+    (-125.7563, 69.4805),
+    (-124.4248, 70.1584),
+    (-124.2896, 69.3996),
+    (-123.0610, 69.5637),
+    (-122.6834, 69.8555),
+    (-121.4722, 69.7977),
+    (-119.9428, 69.3778),
+    (-117.6026, 69.0112),
+    (-116.2264, 68.8414),
+    (-115.2468, 68.9059),
+    (-113.8979, 68.3989),
+    (-115.3048, 67.9026),
+    (-113.4972, 67.6881),
+    (-110.7980, 67.8060),
+    (-109.9461, 67.9810),
+    (-108.8801, 67.3814),
+    (-107.7923, 67.8873),
+    (-108.8129, 68.3116),
+    (-108.1672, 68.6539),
+    (-106.9500, 68.6999),
+    (-106.1500, 68.7999),
+    (-105.3428, 68.5612),
+    (-104.3379, 68.0180),
+    (-103.2211, 68.0977),
+    (-101.4543, 67.6468),
+    (-99.9019, 67.8056),
+    (-98.4432, 67.7816),
+    (-98.5586, 68.4039),
+    (-97.6694, 68.5786),
+    (-96.1199, 68.2394),
+    (-96.1258, 67.2933),
+    (-95.4894, 68.0907),
+    (-94.6849, 68.0638),
+    (-94.2328, 69.0690),
+    (-95.3040, 69.6857),
+    (-96.4713, 70.0897),
+    (-96.3911, 71.1948),
+    (-95.2088, 71.9205),
+    (-93.8899, 71.7601),
+    (-92.8781, 71.3186),
+    (-91.5196, 70.1912),
+    (-92.4069, 69.6999),
+    (-90.5471, 69.4976),
+    (-90.5514, 68.4749),
+    (-89.2151, 69.2587),
+    (-88.0196, 68.6150),
+    (-88.3174, 67.8733),
+    (-87.3501, 67.1987),
+    (-86.3060, 67.9214),
+    (-85.5766, 68.7845),
+    (-85.5219, 69.8820),
+    (-84.1008, 69.8054),
+    (-82.6225, 69.6582),
+    (-81.2804, 69.1620),
+    (-81.2202, 68.6656),
+    (-81.9643, 68.1325),
+    (-81.2592, 67.5971),
+    (-81.3865, 67.1107),
+    (-83.3445, 66.4115),
+    (-84.7354, 66.2572),
+    (-85.7694, 66.5583),
+    (-86.0676, 66.0562),
+    (-87.0314, 65.2129),
+    (-87.3232, 64.7756),
+    (-88.4829, 64.0989),
+    (-89.9144, 64.0327),
+    (-90.7039, 63.6101),
+    (-90.7700, 62.9602),
+    (-91.9334, 62.8350),
+    (-93.1569, 62.0246),
+    (-94.2415, 60.8986),
+    (-94.6293, 60.1102),
+    (-94.6846, 58.9488),
+    (-93.2150, 58.7821),
+    (-92.7646, 57.8457),
+    (-92.2970, 57.0870),
+    (-90.8976, 57.2846),
+    (-89.0395, 56.8517),
+    (-88.0397, 56.4716),
+    (-87.3241, 55.9991),
+    (-86.0712, 55.7238),
+    (-85.0118, 55.3026),
+    (-83.3605, 55.2448),
+    (-82.2728, 55.1483),
+    (-82.4362, 54.2822),
+    (-82.1250, 53.2770),
+    (-81.4007, 52.1578),
+    (-79.9128, 51.2083),
+    (-79.1430, 51.5339),
+    (-78.6019, 52.5620),
+    (-79.1242, 54.1414),
+    (-79.8295, 54.6677),
+    (-78.2287, 55.1364),
+    (-77.0955, 55.8374),
+    (-76.5413, 56.5342),
+    (-76.6231, 57.2026),
+    (-77.3022, 58.0520),
+    (-78.5168, 58.8045),
+    (-77.3367, 59.8526),
+    (-77.7727, 60.7578),
+    (-78.1068, 62.3196),
+    (-77.4106, 62.5505),
+    (-75.6962, 62.2783),
+    (-74.6682, 62.1811),
+    (-73.8398, 62.4437),
+    (-72.9085, 62.1050),
+    (-71.6770, 61.5253),
+    (-71.3736, 61.1371),
+    (-69.5904, 61.0614),
+    (-69.6203, 60.2212),
+    (-69.2878, 58.9573),
+    (-68.3745, 58.8010),
+    (-67.6497, 58.2120),
+    (-66.2017, 58.7673),
+    (-65.2451, 59.8707),
+    (-64.5835, 60.3355),
+    (-63.8047, 59.4425),
+    (-62.5023, 58.1670),
+    (-61.3965, 56.9674),
+    (-61.7986, 56.3394),
+    (-60.4685, 55.7754),
+    (-59.5696, 55.2040),
+    (-57.9750, 54.9454),
+    (-57.3332, 54.6264),
+    (-56.9368, 53.7803),
+    (-56.1581, 53.6474),
+    (-55.7563, 53.2703),
+    (-55.6833, 52.1466),
+    (-56.4091, 51.7706),
+    (-57.1269, 51.4197),
+    (-58.7748, 51.0642),
+    (-60.0331, 50.2427),
+    (-61.7236, 50.0804),
+    (-63.8625, 50.2909),
+    (-65.3633, 50.2981),
+    (-66.3990, 50.2289),
+    (-67.2363, 49.5115),
+    (-68.5111, 49.0683),
+    (-69.9536, 47.7448),
+    (-71.1045, 46.8217),
+    (-70.2552, 46.9860),
+    (-68.6499, 48.2999),
+    (-66.5524, 49.1330),
+    (-65.0562, 49.2327),
+    (-64.1709, 48.7425),
+    (-65.1154, 48.0708),
+    (-64.7985, 46.9929),
+    (-64.4721, 46.2384),
+    (-63.1732, 45.7390),
+    (-61.5207, 45.8837),
+    (-60.5181, 47.0079),
+    (-60.4486, 46.2826),
+    (-59.8028, 45.9204),
+    (-61.0398, 45.2652),
+    (-63.2547, 44.6701),
+    (-64.2465, 44.2655),
+    (-65.3640, 43.5452),
+    (-66.1234, 43.6186),
+    (-66.1617, 44.4651),
+    (-64.4254, 45.2920),
+    (-66.0260, 45.2593),
+    (-67.1374, 45.1375),
+    (-66.9646, 44.8097),
+    (-68.0325, 44.3252),
+    (-69.06, 43.98),
+    (-70.1161, 43.6840),
+    (-70.6454, 43.0902),
+    (-70.8148, 42.8652),
+    (-70.8249, 42.3349),
+    (-70.4949, 41.8049),
+    (-70.0800, 41.7800),
+    (-70.1849, 42.1449),
+    (-69.8849, 41.9228),
+    (-69.9650, 41.6371),
+    (-70.6399, 41.4749),
+    (-71.1203, 41.4944),
+    (-71.8538, 41.3199),
+    (-72.2949, 41.2699),
+    (-72.8764, 41.2206),
+    (-73.71, 40.9311),
+    (-72.2412, 41.1194),
+    (-71.9450, 40.9300),
+    (-73.3450, 40.6300),
+    (-73.9819, 40.6280),
+    (-73.9523, 40.7507),
+    (-74.2567, 40.4734),
+    (-73.9624, 40.4276),
+    (-74.1783, 39.7092),
+    (-74.9060, 38.9395),
+    (-74.9804, 39.1963),
+    (-75.2000, 39.2484),
+    (-75.5280, 39.4984),
+    (-75.3199, 38.9599),
+    (-75.0718, 38.7820),
+    (-75.0567, 38.4041),
+    (-75.3774, 38.0155),
+    (-75.9402, 37.2169),
+    (-76.0312, 37.2565),
+    (-75.7220, 37.9370),
+    (-76.2328, 38.3192),
+    (-76.35, 39.15),
+    (-76.5427, 38.7176),
+    (-76.3293, 38.0832),
+    (-76.9899, 38.2399),
+    (-76.3016, 37.9179),
+    (-76.2587, 36.9664),
+    (-75.9718, 36.8972),
+    (-75.8680, 36.5512),
+    (-75.7274, 35.5507),
+    (-76.3631, 34.8085),
+    (-77.3976, 34.5120),
+    (-78.0549, 33.9254),
+    (-78.5543, 33.8613),
+    (-79.0606, 33.4939),
+    (-79.2035, 33.1583),
+    (-80.3013, 32.5093),
+    (-80.8649, 32.0333),
+    (-81.3362, 31.4404),
+    (-81.4904, 30.7299),
+    (-81.3137, 30.0355),
+    (-80.9799, 29.1800),
+    (-80.5355, 28.4721),
+    (-80.5299, 28.0399),
+    (-80.0565, 26.88),
+    (-80.0880, 26.2057),
+    (-80.1315, 25.8167),
+    (-80.3810, 25.2061),
+    (-80.6800, 25.0799),
+    (-81.1721, 25.2012),
+    (-81.3299, 25.6399),
+    (-81.7099, 25.8699),
+    (-82.2400, 26.7299),
+    (-82.7051, 27.4950),
+    (-82.8552, 27.8862),
+    (-82.6500, 28.5499),
+    (-82.93, 29.1),
+    (-83.7095, 29.9365),
+    (-84.1, 30.09),
+    (-85.1088, 29.6361),
+    (-85.2878, 29.6861),
+    (-85.7731, 30.1526),
+    (-86.3999, 30.4000),
+    (-87.5303, 30.2743),
+    (-88.4178, 30.3849),
+    (-89.1804, 30.3159),
+    (-89.5938, 30.1599),
+    (-89.4137, 29.8941),
+    (-89.43, 29.48864),
+    (-89.2176, 29.2910),
+    (-89.4082, 29.1596),
+    (-89.7792, 29.3071),
+    (-90.1546, 29.1174),
+    (-90.8802, 29.1485),
+    (-91.6267, 29.677),
+    (-92.4990, 29.5523),
+    (-93.2263, 29.7837),
+    (-93.8484, 29.7136),
+    (-94.6900, 29.4800),
+    (-95.6002, 28.7386),
+    (-96.5940, 28.3074),
+    (-97.1400, 27.8300),
+    (-97.3699, 27.3800),
+    (-97.3799, 26.6899),
+    (-97.3299, 26.2100),
+    (-97.1400, 25.8699),
+    (-97.5280, 24.9921),
+    (-97.7029, 24.2723),
+    (-97.7760, 22.9325),
+    (-97.8723, 22.4442),
+    (-97.6990, 21.8986),
+    (-97.3889, 21.4110),
+    (-97.1893, 20.6354),
+    (-96.5255, 19.8909),
+    (-96.2921, 19.3203),
+    (-95.9008, 18.8280),
+    (-94.8390, 18.5627),
+    (-94.4257, 18.1443),
+    (-93.5486, 18.4238),
+    (-92.7861, 18.5248),
+    (-92.0373, 18.7045),
+    (-91.4079, 18.8760),
+    (-90.7718, 19.2841),
+    (-90.5335, 19.8674),
+    (-90.4514, 20.7075),
+    (-90.2786, 20.9998),
+    (-89.6013, 21.2617),
+    (-88.5438, 21.4936),
+    (-87.6584, 21.4588),
+    (-87.0518, 21.5435),
+    (-86.8119, 21.3315),
+    (-86.8459, 20.8498),
+    (-87.3832, 20.2554),
+    (-87.6210, 19.6465),
+    (-87.4367, 19.4724),
+    (-87.5865, 19.0401),
+    (-87.8371, 18.2598),
+    (-88.0906, 18.5166),
+    (-88.3000, 18.4999),
+    (-88.2963, 18.3532),
+    (-88.1068, 18.3486),
+    (-88.1234, 18.0766),
+    (-88.2853, 17.6441),
+    (-88.1978, 17.4894),
+    (-88.3026, 17.1316),
+    (-88.2395, 17.0360),
+    (-88.3554, 16.5307),
+    (-88.5518, 16.2654),
+    (-88.7324, 16.2336),
+    (-88.9306, 15.8872),
+    (-88.6045, 15.7063),
+    (-88.5183, 15.8553),
+    (-88.1899, 15.7199),
+    (-88.1211, 15.6886),
+    (-87.9018, 15.8644),
+    (-87.6156, 15.8787),
+    (-87.5229, 15.7972),
+    (-87.3677, 15.8469),
+    (-86.9031, 15.7567),
+    (-86.4409, 15.7828),
+    (-86.1192, 15.8934),
+    (-86.0019, 16.0054),
+    (-85.6833, 15.9536),
+    (-85.4440, 15.8857),
+    (-85.1824, 15.9091),
+    (-84.9837, 15.9959),
+    (-84.5269, 15.8572),
+    (-84.3682, 15.8351),
+    (-84.0630, 15.6482),
+    (-83.7739, 15.4240),
+    (-83.4103, 15.2709),
+    (-83.1472, 14.9958),
+    (-83.2332, 14.8998),
+    (-83.2841, 14.6766),
+    (-83.1821, 14.3107),
+    (-83.4124, 13.9700),
+    (-83.5198, 13.5676),
+    (-83.5522, 13.1270),
+    (-83.4985, 12.8692),
+    (-83.4733, 12.4190),
+    (-83.6261, 12.3208),
+    (-83.7196, 11.8931),
+    (-83.6508, 11.6290),
+    (-83.8554, 11.3733),
+    (-83.8089, 11.1030),
+    (-83.6556, 10.9387),
+    (-83.5900, 10.7850),
+    (-83.4023, 10.3954),
+    (-83.0156, 9.9929),
+    (-82.5461, 9.5661),
+    (-82.1871, 9.2074),
+    (-82.2075, 8.9955),
+    (-81.8085, 8.9506),
+    (-81.7141, 9.0319),
+    (-81.4392, 8.7862),
+    (-80.9473, 8.8585),
+    (-80.5219, 9.1110),
+    (-79.9145, 9.3127),
+    (-79.5733, 9.6116),
+    (-79.0211, 9.5529),
+    (-79.0584, 9.4545),
+    (-78.5008, 9.4204),
+    (-78.0559, 9.2477),
+    (-77.7295, 8.9468),
+    (-77.3533, 8.6705),
+    (-71.7123, 19.7144),
+    (-71.5873, 19.8849),
+    (-71.3800, 19.9049),
+    (-70.8067, 19.8802),
+    (-70.2143, 19.6228),
+    (-69.9508, 19.6479),
+    (-69.7692, 19.2932),
+    (-69.2221, 19.3132),
+    (-69.2543, 19.0151),
+    (-68.8094, 18.9791),
+    (-68.3179, 18.6121),
+    (-68.6893, 18.2051),
+    (-69.1649, 18.4226),
+    (-69.6239, 18.3807),
+    (-69.9529, 18.4283),
+    (-70.1332, 18.2459),
+    (-70.5171, 18.1842),
+    (-70.6692, 18.4268),
+    (-70.9999, 18.2833),
+    (-71.4002, 17.5985),
+    (-71.6576, 17.7575),
+    (-71.7083, 18.0449),
+    (-72.3724, 18.2149),
+    (-72.8444, 18.1456),
+    (-73.4545, 18.2179),
+    (-73.9224, 18.0309),
+    (-74.4580, 18.3425),
+    (-74.3699, 18.6649),
+    (-73.4495, 18.5260),
+    (-72.6949, 18.4457),
+    (-72.3348, 18.6684),
+    (-72.7916, 19.1016),
+    (-72.7841, 19.4835),
+    (-73.4150, 19.6395),
+    (-73.1897, 19.9156),
+    (-72.5796, 19.8715),
+    (-71.7123, 19.7144),
+    (14.7612, 38.1438),
+    (15.5203, 38.2311),
+    (15.1602, 37.4440),
+    (15.3098, 37.1342),
+    (15.0999, 36.6199),
+    (14.3352, 36.9966),
+    (13.8267, 37.1045),
+    (12.4310, 37.6129),
+    (12.5709, 38.1263),
+    (13.7411, 38.0349),
+    (14.7612, 38.1438),
+    (37.5391, 44.6572),
+    (38.6799, 44.2799),
+    (39.9550, 43.4349),
+    (132.3711, 33.4636),
+    (132.9243, 34.0602),
+    (133.4929, 33.9446),
+    (133.9041, 34.3649),
+    (134.6384, 34.1492),
+    (134.7663, 33.8063),
+    (134.2034, 33.2011),
+    (133.7929, 33.5219),
+    (133.2802, 33.2895),
+    (133.0148, 32.7045),
+    (132.3631, 32.9893),
+    (132.3711, 33.4636),
+    (180.0000, 68.9636),
+    (178.5999, 69.4000),
+    (175.7240, 69.8772),
+    (173.6439, 69.8174),
+    (170.4534, 70.0970),
+    (170.0082, 69.6527),
+    (170.8168, 69.0136),
+    (169.5776, 68.6938),
+    (167.8629, 69.5687),
+    (165.9403, 69.4719),
+    (164.0524, 69.6682),
+    (162.2790, 69.6420),
+    (160.9405, 69.4372),
+    (159.7086, 69.7219),
+    (159.8303, 70.4532),
+    (158.9977, 70.8667),
+    (157.0068, 71.0314),
+    (152.9688, 70.8422),
+    (150.3511, 71.6064),
+    (149.5000, 72.1999),
+    (140.4681, 72.8494),
+    (139.1479, 72.4161),
+    (139.8698, 71.4878),
+    (138.2340, 71.6280),
+    (137.4975, 71.3476),
+    (135.5619, 71.6552),
+    (133.8576, 71.3864),
+    (132.2535, 71.8363),
+    (131.2885, 70.7869),
+    (129.7159, 71.1930),
+    (128.46, 71.98),
+    (129.0515, 72.3987),
+    (128.5912, 73.0387),
+    (126.9764, 73.5654),
+    (125.38, 73.56),
+    (123.2577, 73.7350),
+    (123.2006, 72.9712),
+    (119.02, 73.12),
+    (118.7763, 73.5877),
+    (115.5678, 73.7528),
+    (113.9688, 73.5948),
+    (113.5295, 73.3350),
+    (113.0195, 73.9769),
+    (112.1191, 73.7877),
+    (110.64, 74.04),
+    (109.4, 74.18),
+    (110.1512, 74.4767),
+    (112.7791, 75.0318),
+    (113.8853, 75.3277),
+    (114.1341, 75.8476),
+    (113.3315, 76.2222),
+    (111.07726, 76.71),
+    (108.1537, 76.7233),
+    (107.2399, 76.4799),
+    (106.9701, 76.9741),
+    (104.7050, 77.1273),
+    (106.0666, 77.3738),
+    (104.3515, 77.6979),
+    (101.9908, 77.2875),
+    (101.0353, 76.8618),
+    (100.7596, 76.4302),
+    (98.9225, 76.4468),
+    (96.6782, 75.9154),
+    (95.8600, 76.1400),
+    (93.2342, 76.0471),
+    (92.9006, 75.7733),
+    (90.2599, 75.6399),
+    (88.3156, 75.1439),
+    (87.1668, 75.1164),
+    (86.0095, 74.4596),
+    (86.8223, 73.9368),
+    (84.6552, 73.8059),
+    (82.2499, 73.8500),
+    (80.5110, 73.6482),
+    (80.6107, 72.5828),
+    (81.5000, 71.7499),
+    (79.6520, 72.3201),
+    (77.5766, 72.2671),
+    (75.9031, 71.8740),
+    (76.3591, 71.1528),
+    (75.2889, 71.3355),
+    (75.6835, 72.3005),
+    (75.1580, 72.8549),
+    (74.6592, 72.8322),
+    (74.8908, 72.1211),
+    (73.1011, 71.4471),
+    (74.3998, 70.6317),
+    (73.6018, 69.6276),
+    (73.8423, 69.0714),
+    (74.9358, 68.9891),
+    (74.4692, 68.3289),
+    (75.052, 67.76047),
+    (74.1865, 67.2842),
+    (73.9209, 66.7894),
+    (72.8207, 66.5326),
+    (72.4230, 66.1726),
+    (71.28, 66.32),
+    (73.2387, 67.7404),
+    (73.6678, 68.4079),
+    (72.5646, 69.0208),
+    (72.7918, 70.3911),
+    (72.4701, 71.0901),
+    (71.8481, 71.4089),
+    (72.7960, 72.2200),
+    (72.5875, 72.7762),
+    (69.94, 73.04),
+    (69.1963, 72.8433),
+    (68.5400, 71.9345),
+    (66.6946, 71.0289),
+    (66.7249, 70.7088),
+    (67.2597, 69.9287),
+    (66.9300, 69.4546),
+    (68.1352, 69.3564),
+    (68.1644, 69.1443),
+    (69.1806, 68.6156),
+    (68.5121, 68.0923),
+    (64.8881, 69.2348),
+    (63.5040, 69.5473),
+    (60.5500, 69.8500),
+    (60.03, 69.52),
+    (61.0778, 68.9406),
+    (59.9414, 68.2784),
+    (58.802, 68.88082),
+    (57.3170, 68.4662),
+    (55.4426, 68.4386),
+    (54.7530, 68.0868),
+    (53.4858, 68.2013),
+    (54.4717, 68.8081),
+    (53.7174, 68.8573),
+    (48.1387, 67.5223),
+    (47.8941, 66.8845),
+    (46.3491, 66.6676),
+    (45.5620, 67.0100),
+    (45.5551, 67.5665),
+    (46.8213, 67.6899),
+    (46.2500, 68.2499),
+    (43.4528, 68.5708),
+    (44.1747, 67.9616),
+    (43.6983, 67.3524),
+    (44.5322, 66.7563),
+    (43.9497, 66.0690),
+    (43.0160, 66.4185),
+    (42.0930, 66.4762),
+    (39.7626, 65.4968),
+    (40.4356, 64.7644),
+    (39.5934, 64.5207),
+    (37.1760, 65.1432),
+    (36.5395, 64.7644),
+    (37.1419, 64.3347),
+    (37.0127, 63.8498),
+    (36.2312, 64.1094),
+    (34.9439, 64.4143),
+    (34.8785, 65.4362),
+    (34.8147, 65.9001),
+    (33.1844, 66.6325),
+    (33.9186, 66.7595),
+    (38.3829, 65.9995),
+    (40.0158, 66.2661),
+    (41.1259, 66.7915),
+    (41.0598, 67.4571),
+    (40.2923, 67.9323),
+    (36.5139, 69.0634),
+    (33.7754, 69.3014),
+    (32.1327, 69.9059),
+    (31.1010, 69.5580),
+    (30.0054, 70.1862),
+    (31.2934, 70.4537),
+    (28.1655, 71.1854),
+    (26.3700, 70.9862),
+    (24.5465, 71.0304),
+    (23.0237, 70.2020),
+    (21.3784, 70.2551),
+    (19.1840, 69.8174),
+    (16.4359, 68.5632),
+    (14.7611, 67.8106),
+    (12.3583, 65.8797),
+    (10.5277, 64.4860),
+    (8.5534, 63.4540),
+    (5.9129, 62.6144),
+    (4.9920, 61.9709),
+    (5.3082, 59.6632),
+    (5.6658, 58.5881),
+    (7.0487, 58.0788),
+    (8.3820, 58.3132),
+    (10.3565, 59.4698),
+    (11.0273, 58.8561),
+    (11.7879, 57.4418),
+    (12.6251, 56.3070),
+    (12.9429, 55.3617),
+    (14.1007, 55.4077),
+    (14.6666, 56.2008),
+    (15.8797, 56.1043),
+    (16.4477, 57.0411),
+    (16.8291, 58.7198),
+    (17.8692, 58.9537),
+    (18.7877, 60.0819),
+    (17.8313, 60.6365),
+    (17.1195, 61.3411),
+    (17.8477, 62.7494),
+    (19.7788, 63.6095),
+    (21.3696, 64.4135),
+    (21.2135, 65.0260),
+    (22.1831, 65.7237),
+    (23.9033, 66.0069),
+    (25.2940, 65.5343),
+    (25.3980, 65.1114),
+    (24.7305, 64.9023),
+    (22.4427, 63.8178),
+    (21.5360, 63.1897),
+    (21.0592, 62.6073),
+    (21.5448, 61.7053),
+    (21.3222, 60.7201),
+    (22.2907, 60.3919),
+    (22.8696, 59.8463),
+    (24.4966, 60.0573),
+    (26.2551, 60.4239),
+    (28.0699, 60.5035),
+    (29.1176, 60.0280),
+    (27.9811, 59.4753),
+    (26.9491, 59.4458),
+    (25.8641, 59.6110),
+    (24.6042, 59.4658),
+    (23.3397, 59.1872),
+    (23.4265, 58.6127),
+    (24.0611, 58.2573),
+    (24.4289, 58.3834),
+    (24.3128, 57.7934),
+    (24.1207, 57.0256),
+    (23.3184, 57.0062),
+    (22.5243, 57.7533),
+    (21.5818, 57.4118),
+    (21.0904, 56.7838),
+    (21.0558, 56.0310),
+    (21.2684, 55.1904),
+    (19.8884, 54.8661),
+    (19.6606, 54.4260),
+    (18.6962, 54.4387),
+    (18.6208, 54.6826),
+    (17.6228, 54.8515),
+    (16.3634, 54.5131),
+    (14.8029, 54.0507),
+    (14.1196, 53.7570),
+    (13.6474, 54.0755),
+    (12.5184, 54.4703),
+    (11.9562, 54.1964),
+    (10.9394, 54.0086),
+    (10.9501, 54.3636),
+    (9.9395, 54.5966),
+    (9.9219, 54.9831),
+    (9.6499, 55.4699),
+    (10.3699, 56.1900),
+    (10.6678, 56.0813),
+    (10.9121, 56.4586),
+    (10.3699, 56.6099),
+    (10.2500, 56.8900),
+    (10.5461, 57.2157),
+    (10.5800, 57.7300),
+    (9.7755, 57.4479),
+    (9.4244, 57.1720),
+    (8.5434, 57.1100),
+    (8.2565, 56.8099),
+    (8.0899, 56.5400),
+    (8.1203, 55.5177),
+    (8.5262, 54.9627),
+    (8.5721, 54.3956),
+    (8.8007, 54.0207),
+    (8.1217, 53.5277),
+    (7.9362, 53.7482),
+    (7.1004, 53.6939),
+    (6.9051, 53.4821),
+    (6.0741, 53.5104),
+    (4.7059, 53.0917),
+    (3.8302, 51.6205),
+    (3.3149, 51.3457),
+    (2.5135, 51.1485),
+    (1.6390, 50.9466),
+    (1.3387, 50.1271),
+    (-0.9894, 49.3473),
+    (-1.9334, 49.7763),
+    (-1.6165, 48.6444),
+    (-3.2958, 48.9016),
+    (-4.5923, 48.6841),
+    (-4.4915, 47.9549),
+    (-2.9632, 47.5703),
+    (-2.2257, 47.0643),
+    (-1.1937, 46.0149),
+    (-1.3842, 44.0226),
+    (-1.9013, 43.4228),
+    (-3.5175, 43.4559),
+    (-4.3478, 43.4034),
+    (-5.4118, 43.5742),
+    (-6.7544, 43.5679),
+    (-7.9781, 43.7483),
+    (-9.3928, 43.0266),
+    (-8.9844, 42.5927),
+    (-9.0348, 41.8805),
+    (-8.9907, 41.5434),
+    (-8.7908, 41.1843),
+    (-8.7686, 40.7606),
+    (-8.9773, 40.1593),
+    (-9.0483, 39.7550),
+    (-9.4469, 39.3920),
+    (-9.5265, 38.7374),
+    (-9.2874, 38.3584),
+    (-8.8399, 38.2662),
+    (-8.7461, 37.6513),
+    (-8.8988, 36.8688),
+    (-8.3828, 36.9788),
+    (-7.8556, 36.8382),
+    (-7.4537, 37.0977),
+    (-6.5201, 36.9429),
+    (-6.2366, 36.3676),
+    (-5.8664, 36.0298),
+    (-5.3771, 35.9468),
+    (-4.9952, 36.3247),
+    (-4.3689, 36.6778),
+    (-3.4157, 36.6588),
+    (-2.1464, 36.6741),
+    (-1.4383, 37.4430),
+    (-0.6833, 37.6423),
+    (-0.4671, 38.2923),
+    (0.1112, 38.7385),
+    (-0.2787, 39.3099),
+    (0.1066, 40.1239),
+    (0.7213, 40.6783),
+    (0.8105, 41.0147),
+    (2.0918, 41.2260),
+    (3.0394, 41.8921),
+    (2.9859, 42.4730),
+    (3.1004, 43.0752),
+    (4.5569, 43.3996),
+    (6.5292, 43.1288),
+    (7.4351, 43.6938),
+    (7.8507, 43.7671),
+    (8.4285, 44.2312),
+    (8.8889, 44.3663),
+    (9.7024, 44.0362),
+    (10.2000, 43.9200),
+    (10.5119, 42.9314),
+    (11.1919, 42.3554),
+    (12.1066, 41.7045),
+    (12.8880, 41.2530),
+    (13.6279, 41.1882),
+    (14.0606, 40.7863),
+    (14.7032, 40.6045),
+    (14.9984, 40.1729),
+    (15.4136, 40.0483),
+    (15.7188, 39.5440),
+    (16.1093, 38.9645),
+    (15.8919, 38.7509),
+    (15.6879, 38.2145),
+    (15.6840, 37.9088),
+    (16.1009, 37.9858),
+    (16.6350, 38.8435),
+    (17.0528, 38.9028),
+    (17.1714, 39.4246),
+    (16.4487, 39.7954),
+    (16.8695, 40.4422),
+    (17.7383, 40.2776),
+    (18.2933, 39.8107),
+    (18.4802, 40.1688),
+    (18.3766, 40.3556),
+    (17.5191, 40.8771),
+    (16.7850, 41.1796),
+    (15.8893, 41.5410),
+    (16.1698, 41.7402),
+    (15.9261, 41.9613),
+    (15.1425, 41.9551),
+    (14.0298, 42.7610),
+    (13.5269, 43.5877),
+    (12.5892, 44.0913),
+    (12.2614, 44.6004),
+    (12.3838, 44.8853),
+    (12.3285, 45.3817),
+    (13.1416, 45.7366),
+    (13.9376, 45.5910),
+    (13.7150, 45.5003),
+    (13.6794, 45.4841),
+    (13.6569, 45.1369),
+    (13.9522, 44.8021),
+    (14.2587, 45.2337),
+    (14.9016, 45.0760),
+    (14.9203, 44.7384),
+    (15.3762, 44.3179),
+    (15.1744, 44.2431),
+    (16.0153, 43.5072),
+    (16.9300, 43.2099),
+    (17.5099, 42.8499),
+    (18.4500, 42.4799),
+    (18.8821, 42.2815),
+    (19.1624, 41.9550),
+    (19.3717, 41.8775),
+    (19.5400, 41.7199),
+    (19.4035, 41.4095),
+    (19.3190, 40.7272),
+    (19.4060, 40.2507),
+    (19.9600, 39.9150),
+    (19.9800, 39.6949),
+    (20.1500, 39.6249),
+    (20.2177, 39.3402),
+    (20.7300, 38.7699),
+    (21.1200, 38.3103),
+    (21.2950, 37.6449),
+    (21.6700, 36.8449),
+    (22.4900, 36.4100),
+    (23.1542, 36.4225),
+    (22.7749, 37.3050),
+    (23.4099, 37.4099),
+    (23.1150, 37.9200),
+    (24.0400, 37.6550),
+    (24.0250, 38.2199),
+    (23.5300, 38.5100),
+    (22.9730, 38.9709),
+    (23.3500, 39.1900),
+    (22.8497, 39.6593),
+    (22.6262, 40.2565),
+    (22.8139, 40.4760),
+    (23.3429, 39.9609),
+    (23.8999, 39.9620),
+    (24.4079, 40.1249),
+    (23.7148, 40.6871),
+    (24.9258, 40.9470),
+    (25.4476, 40.8525),
+    (26.0569, 40.8241),
+    (26.0433, 40.6177),
+    (26.3580, 40.1519),
+    (27.1923, 40.6905),
+    (27.6190, 40.9998),
+    (28.8064, 41.0549),
+    (28.9884, 41.2999),
+    (28.1155, 41.6228),
+    (27.9967, 42.0073),
+    (27.6738, 42.5778),
+    (28.0390, 43.2931),
+    (28.5580, 43.7074),
+    (28.8378, 44.9138),
+    (29.1416, 44.8202),
+    (29.6265, 45.0353),
+    (29.6032, 45.2933),
+    (30.3776, 46.0324),
+    (30.7487, 46.5831),
+    (31.6753, 46.7062),
+    (31.7441, 46.3333),
+    (33.2985, 46.0805),
+    (33.5881, 45.8515),
+    (32.6308, 45.5191),
+    (32.4541, 45.3274),
+    (33.5469, 45.0347),
+    (33.3264, 44.5648),
+    (33.8825, 44.3614),
+    (35.2399, 44.9399),
+    (36.3347, 45.1132),
+    (36.5299, 45.4699),
+    (35.5100, 45.4099),
+    (35.0207, 45.6512),
+    (34.9623, 46.2731),
+    (35.8236, 46.6459),
+    (36.7598, 46.6987),
+    (37.4251, 47.0222),
+    (38.2235, 47.1021),
+    (39.1212, 47.2633),
+    (39.1476, 47.0447),
+    (37.6737, 46.6365),
+    (38.2329, 46.2408),
+    (37.4031, 45.4045),
+    (36.6754, 45.2446),
+    (37.5391, 44.6572),
+    (38.6799, 44.2799),
+    (39.9550, 43.4349),
+    (40.3213, 43.1286),
+    (40.8754, 43.0136),
+    (41.4534, 42.6451),
+    (41.7031, 41.9629),
+    (41.5540, 41.5356),
+    (40.3734, 41.0136),
+    (39.5126, 41.1027),
+    (38.3476, 40.9485),
+    (36.9131, 41.3353),
+    (35.1677, 42.0402),
+    (33.5132, 42.0189),
+    (32.3479, 41.7362),
+    (31.1459, 41.0876),
+    (29.2400, 41.2199),
+    (28.8199, 40.4600),
+    (27.2800, 40.4200),
+    (26.1707, 39.4636),
+    (26.8047, 38.9857),
+    (26.3182, 38.2081),
+    (27.0487, 37.6533),
+    (27.6411, 36.6588),
+    (28.7329, 36.6768),
+    (29.6999, 36.1443),
+    (30.3910, 36.2629),
+    (30.6216, 36.6778),
+    (31.6995, 36.6442),
+    (32.5091, 36.1075),
+    (34.0268, 36.2199),
+    (34.7145, 36.7955),
+    (35.5509, 36.5654),
+    (36.1608, 36.6506),
+    (35.7820, 36.2749),
+    (36.1497, 35.8215),
+    (35.9050, 35.4100),
+    (35.9984, 34.6449),
+    (35.9795, 34.6100),
+    (35.4822, 33.9054),
+    (35.1260, 33.0909),
+    (35.0984, 33.0805),
+    (34.9554, 32.8273),
+    (34.7525, 32.0729),
+    (34.4881, 31.6055),
+    (34.5563, 31.5488),
+    (34.2654, 31.2193),
+    (33.7733, 30.9674),
+    (32.9939, 31.0240),
+    (32.1924, 31.2603),
+    (31.9604, 30.9336),
+    (31.6879, 31.4296),
+    (30.9769, 31.5558),
+    (30.0950, 31.4734),
+    (29.6834, 31.1868),
+    (28.9135, 30.8700),
+    (28.4504, 31.0257),
+    (27.4576, 31.3212),
+    (26.4953, 31.5856),
+    (25.1648, 31.5691),
+    (24.9211, 31.8993),
+    (23.9275, 32.0166),
+    (23.6091, 32.1872),
+    (23.2368, 32.1914),
+    (22.8957, 32.6385),
+    (21.5430, 32.8432),
+    (20.8545, 32.7067),
+    (20.1339, 32.2381),
+    (19.8203, 31.7517),
+    (20.0533, 30.9857),
+    (19.5740, 30.5258),
+    (19.0864, 30.2663),
+    (18.0211, 30.7635),
+    (16.6116, 31.1821),
+    (15.7139, 31.3762),
+    (15.2456, 32.2650),
+    (13.9186, 32.7119),
+    (13.0832, 32.8788),
+    (12.6633, 32.7927),
+    (11.4887, 33.1369),
+    (11.1085, 33.2933),
+    (10.8568, 33.7687),
+    (10.3396, 33.7857),
+    (10.1495, 34.3307),
+    (10.8078, 34.8335),
+    (10.9395, 35.6989),
+    (10.5932, 35.9474),
+    (10.6000, 36.4100),
+    (11.1000, 36.8999),
+    (11.0288, 37.0921),
+    (10.1806, 36.7240),
+    (10.2100, 37.2300),
+    (9.5099, 37.3499),
+    (8.4209, 36.9464),
+    (7.7370, 36.8857),
+    (7.3303, 37.1183),
+    (6.2618, 37.1106),
+    (5.3201, 36.7165),
+    (4.8157, 36.8650),
+    (3.1616, 36.7839),
+    (1.4669, 36.6056),
+    (0.5038, 36.3012),
+    (-0.1274, 35.8886),
+    (-1.2086, 35.7148),
+    (-2.1699, 35.1683),
+    (-2.6043, 35.1790),
+    (-3.6400, 35.3998),
+    (-4.5910, 35.3307),
+    (-5.1938, 35.7551),
+    (-5.9299, 35.7599),
+    (-6.2443, 35.1458),
+    (-6.9125, 34.1104),
+    (-7.6541, 33.6970),
+    (-8.6574, 33.2402),
+    (-9.3006, 32.5646),
+    (-9.4347, 32.0380),
+    (-9.8147, 31.1777),
+    (-9.5648, 29.9335),
+    (-10.3995, 29.0985),
+    (-10.9009, 28.8321),
+    (-11.6889, 28.1486),
+    (-12.6188, 28.0381),
+    (-13.1399, 27.6401),
+    (-13.7738, 26.6188),
+    (-14.4399, 26.2544),
+    (-14.8009, 25.6362),
+    (-14.8246, 25.1035),
+    (-15.0893, 24.5202),
+    (-15.4260, 24.3591),
+    (-15.9826, 23.7233),
+    (-16.3264, 23.0177),
+    (-16.2619, 22.6793),
+    (-16.5891, 22.1582),
+    (-16.9732, 21.8857),
+    (-17.0204, 21.4223),
+    (-17.0634, 20.9997),
+    (-16.5363, 20.5678),
+    (-16.2778, 20.0925),
+    (-16.3776, 19.5938),
+    (-16.2568, 19.0967),
+    (-16.1463, 18.1084),
+    (-16.2705, 17.1669),
+    (-16.5497, 16.6738),
+    (-16.4630, 16.1350),
+    (-16.7007, 15.6215),
+    (-17.1851, 14.9194),
+    (-17.6250, 14.7295),
+    (-17.1261, 14.3735),
+    (-16.7137, 13.5949),
+    (-16.8415, 13.1513),
+    (-16.6774, 12.3848),
+    (-16.6138, 12.1709),
+    (-16.3089, 11.9587),
+    (-16.3147, 11.8065),
+    (-16.0852, 11.5245),
+    (-15.6641, 11.4584),
+    (-15.1303, 11.0404),
+    (-14.8395, 10.8765),
+    (-14.6932, 10.6563),
+    (-14.5796, 10.2144),
+    (-14.3300, 10.0157),
+    (-14.0740, 9.8861),
+    (-13.6851, 9.4947),
+    (-13.2465, 8.9030),
+    (-13.1240, 8.1639),
+    (-12.9490, 7.7986),
+    (-12.4280, 7.2629),
+    (-11.7081, 6.8600),
+    (-11.4387, 6.7859),
+    (-10.7653, 6.1407),
+    (-9.9134, 5.5935),
+    (-9.0047, 4.8324),
+    (-7.9741, 4.3557),
+    (-7.7121, 4.3645),
+    (-7.5189, 4.3382),
+    (-6.5287, 4.7050),
+    (-5.8344, 4.9937),
+    (-4.6499, 5.1682),
+    (-4.0088, 5.1798),
+    (-3.3110, 4.9842),
+    (-2.8561, 4.9944),
+    (-1.9647, 4.7104),
+    (-1.0636, 5.0005),
+    (-0.5076, 5.3434),
+    (1.0601, 5.9288),
+    (1.8652, 6.1421),
+    (2.6917, 6.2588),
+    (3.5741, 6.2583),
+    (4.3256, 6.2706),
+    (5.0335, 5.6118),
+    (5.3628, 4.8879),
+    (5.8981, 4.2624),
+    (6.6980, 4.2405),
+    (7.0825, 4.4646),
+    (7.4621, 4.4121),
+    (8.5002, 4.7719),
+    (8.4888, 4.4956),
+    (8.7449, 4.3522),
+    (8.9481, 3.9041),
+    (9.4043, 3.7345),
+    (9.7951, 3.0734),
+    (9.6491, 2.2838),
+    (9.3056, 1.1609),
+    (9.4928, 1.0101),
+    (9.2913, 0.2686),
+    (9.0484, -0.4593),
+    (8.8300, -0.7790),
+    (8.7979, -1.1113),
+    (9.4052, -2.1443),
+    (10.0661, -2.9694),
+    (11.0937, -3.9788),
+    (11.9149, -5.0379),
+    (12.1823, -5.7899),
+    (12.3224, -6.1000),
+    (12.2273, -6.2944),
+    (12.7282, -6.9271),
+    (12.9330, -7.5965),
+    (13.2364, -8.5626),
+    (12.9290, -8.9590),
+    (12.8753, -9.1669),
+    (13.1209, -9.7668),
+    (13.3873, -10.3735),
+    (13.6863, -10.7310),
+    (13.7387, -11.2978),
+    (13.6337, -12.0386),
+    (13.3129, -12.4836),
+    (12.7384, -13.1379),
+    (12.5000, -13.5476),
+    (12.1756, -14.4491),
+    (12.1235, -14.8783),
+    (11.7785, -15.7938),
+    (11.6400, -16.6731),
+    (11.7341, -17.3018),
+    (11.7949, -18.0691),
+    (12.6085, -19.0453),
+    (12.8268, -19.6731),
+    (13.3524, -20.8728),
+    (13.8686, -21.6990),
+    (14.2577, -22.1112),
+    (14.3857, -22.6566),
+    (14.4081, -23.8530),
+    (14.7432, -25.3929),
+    (14.9897, -26.1173),
+    (15.2104, -27.0909),
+    (15.6018, -27.8212),
+    (16.3449, -28.5767),
+    (17.0629, -29.8759),
+    (17.0644, -29.8786),
+    (17.5669, -30.7257),
+    (18.2217, -31.6616),
+    (18.2479, -32.4291),
+    (17.9251, -32.6112),
+    (18.2500, -33.2814),
+    (18.2444, -33.8677),
+    (18.3774, -34.1365),
+    (18.4246, -33.9978),
+    (18.8553, -34.4443),
+    (19.1932, -34.4625),
+    (19.6164, -34.8191),
+    (20.0712, -34.7951),
+    (20.6890, -34.4171),
+    (21.5427, -34.2588),
+    (22.5741, -33.8640),
+    (22.9881, -33.9164),
+    (23.5940, -33.7944),
+    (24.6778, -33.9871),
+    (25.1728, -33.7968),
+    (25.7806, -33.9446),
+    (25.9096, -33.6670),
+    (26.4194, -33.6149),
+    (27.4646, -33.2269),
+    (28.2197, -32.7719),
+    (28.9255, -32.1720),
+    (30.0557, -31.1402),
+    (30.6228, -30.4237),
+    (30.9017, -29.9099),
+    (31.3255, -29.4019),
+    (31.5210, -29.2573),
+    (32.2033, -28.7524),
+    (32.4621, -28.3010),
+    (32.5802, -27.4701),
+    (32.8301, -26.7421),
+    (32.9159, -26.2158),
+    (32.6603, -26.1485),
+    (32.5746, -25.7273),
+    (33.0132, -25.3575),
+    (34.2158, -24.8163),
+    (35.0407, -24.4783),
+    (35.4587, -24.1226),
+    (35.6074, -23.7065),
+    (35.3717, -23.5353),
+    (35.5339, -23.0707),
+    (35.5625, -22.09),
+    (35.3858, -22.14),
+    (35.3734, -21.8408),
+    (35.1761, -21.2543),
+    (34.7018, -20.4970),
+    (34.7863, -19.7840),
+    (35.1983, -19.5528),
+    (35.8964, -18.8422),
+    (36.2812, -18.6596),
+    (37.4111, -17.5863),
+    (38.5383, -17.1010),
+    (39.4525, -16.7208),
+    (40.0892, -16.1007),
+    (40.4772, -15.4062),
+    (40.7754, -14.6917),
+    (40.5996, -14.2019),
+    (40.5608, -12.6391),
+    (40.4372, -11.7617),
+    (40.4783, -10.7654),
+    (40.3165, -10.3170),
+    (39.9495, -10.0984),
+    (39.5357, -9.1123),
+    (39.1865, -8.4855),
+    (39.2520, -8.0078),
+    (39.1946, -7.7039),
+    (39.4699, -7.0999),
+    (39.4400, -6.8399),
+    (38.7997, -6.4756),
+    (38.7405, -5.9089),
+    (39.2022, -4.6767),
+    (39.6049, -4.3465),
+    (39.8000, -3.6811),
+    (40.1211, -3.2776),
+    (40.2630, -2.5730),
+    (40.6378, -2.4997),
+    (40.8847, -2.0825),
+    (41.5851, -1.6832),
+    (41.8109, -1.4464),
+    (42.0415, -0.9191),
+    (43.1359, 0.2921),
+    (44.0681, 1.0528),
+    (45.5639, 2.0457),
+    (46.5647, 2.8552),
+    (47.7407, 4.2194),
+    (48.5945, 5.3391),
+    (49.4527, 6.8046),
+    (50.0709, 8.0817),
+    (50.5523, 9.1987),
+    (50.8341, 10.2797),
+    (51.0452, 10.6409),
+    (51.0415, 11.1665),
+    (51.1338, 11.7481),
+    (51.1112, 12.0246),
+    (50.7320, 12.0219),
+    (50.2587, 11.6795),
+    (49.7286, 11.5789),
+    (49.2677, 11.4303),
+    (48.9482, 11.4106),
+    (48.3787, 11.3754),
+    (48.0215, 11.1930),
+    (47.5256, 11.1272),
+    (46.6454, 10.8165),
+    (45.5569, 10.6980),
+    (44.6142, 10.4422),
+    (44.1178, 10.4455),
+    (43.6666, 10.8641),
+    (43.4706, 11.2777),
+    (43.1453, 11.4620),
+    (42.7158, 11.7356),
+    (43.2863, 11.9749),
+    (43.3178, 12.3901),
+    (43.0812, 12.6996),
+    (42.5895, 13.0004),
+    (42.2768, 13.3439),
+    (41.7349, 13.9210),
+    (41.1792, 14.4910),
+    (39.8142, 15.4356),
+    (39.2661, 15.9227),
+    (38.9906, 16.8406),
+    (38.4100, 17.9983),
+    (37.8627, 18.3678),
+    (37.4817, 18.6140),
+    (37.1147, 19.8079),
+    (36.9694, 20.8374),
+    (37.1887, 21.0188),
+    (36.86623, 22.0),
+    (36.6907, 22.2048),
+    (35.5259, 23.1024),
+    (35.4937, 23.7523),
+    (35.6924, 23.9267),
+    (34.7950, 25.0337),
+    (34.4738, 25.5985),
+    (34.1045, 26.1422),
+    (33.3487, 27.6998),
+    (32.7348, 28.7052),
+    (32.3204, 29.7604),
+    (32.4232, 29.8510),
+    (33.1367, 28.4176),
+    (33.5881, 27.9713),
+    (33.9213, 27.6487),
+    (34.1545, 27.8233),
+    (34.4265, 28.3439),
+    (34.6417, 29.0994),
+    (34.9226, 29.5013),
+    (34.9560, 29.3565),
+    (34.8322, 28.9574),
+    (34.7877, 28.6074),
+    (34.6323, 28.0585),
+    (35.1301, 28.0633),
+    (35.6401, 27.3765),
+    (36.2491, 26.5701),
+    (36.6396, 25.8262),
+    (36.9316, 25.6029),
+    (37.2094, 25.0845),
+    (37.1548, 24.8584),
+    (37.4836, 24.2854),
+    (38.0238, 24.0786),
+    (38.4927, 23.6884),
+    (39.0663, 22.5796),
+    (39.0236, 21.9868),
+    (39.1393, 21.2919),
+    (39.8016, 20.3388),
+    (40.2476, 20.1746),
+    (40.9393, 19.4864),
+    (41.2213, 18.6715),
+    (41.7543, 17.8330),
+    (42.2708, 17.4747),
+    (42.3479, 17.0758),
+    (42.6495, 16.7746),
+    (42.7793, 16.3478),
+    (42.8236, 15.9117),
+    (42.7024, 15.7188),
+    (42.8050, 15.2619),
+    (42.6048, 15.2133),
+    (42.8922, 14.8022),
+    (43.0879, 14.0626),
+    (43.2514, 13.7675),
+    (43.2228, 13.2209),
+    (43.4829, 12.6368),
+    (44.1751, 12.5859),
+    (44.4945, 12.7216),
+    (44.9895, 12.6995),
+    (45.1443, 12.9539),
+    (45.4064, 13.0269),
+    (45.6250, 13.2909),
+    (45.8775, 13.3477),
+    (46.7170, 13.3996),
+    (47.3544, 13.5922),
+    (47.9389, 14.0072),
+    (48.2389, 13.9480),
+    (48.6792, 14.0032),
+    (49.5745, 14.7087),
+    (51.1725, 15.1752),
+    (52.1681, 15.5974),
+    (52.1917, 15.9384),
+    (52.3852, 16.3824),
+    (53.1085, 16.6510),
+    (53.5705, 16.7076),
+    (54.2392, 17.0449),
+    (54.7910, 16.9506),
+    (55.2749, 17.2283),
+    (55.2699, 17.6323),
+    (55.6614, 17.8841),
+    (56.2835, 17.8760),
+    (56.5121, 18.0871),
+    (56.6096, 18.5742),
+    (57.2342, 18.9479),
+    (57.6943, 18.9447),
+    (57.7887, 19.0675),
+    (57.6657, 19.7360),
+    (57.8263, 20.2430),
+    (58.0343, 20.4814),
+    (58.4879, 20.4289),
+    (58.8611, 21.1140),
+    (59.2824, 21.4338),
+    (59.4421, 21.7145),
+    (59.8061, 22.3105),
+    (59.8080, 22.5336),
+    (59.4500, 22.6602),
+    (59.1805, 22.9923),
+    (58.7292, 23.5656),
+    (58.1369, 23.7479),
+    (57.4034, 23.8785),
+    (56.8451, 24.2416),
+    (56.3968, 24.9247),
+    (56.2610, 25.7146),
+    (56.3914, 25.8959),
+    (56.4856, 26.3091),
+    (56.3620, 26.3959),
+    (56.0708, 26.0554),
+    (55.4390, 25.4391),
+    (54.6930, 24.7978),
+    (54.0080, 24.1217),
+    (53.4040, 24.1513),
+    (52.5770, 24.1774),
+    (51.7943, 24.0198),
+    (51.7574, 24.2940),
+    (51.5795, 24.2454),
+    (51.3896, 24.6273),
+    (51.6067, 25.2156),
+    (51.5890, 25.8011),
+    (51.2864, 26.1145),
+    (51.0133, 26.0069),
+    (50.7439, 25.4824),
+    (50.8101, 24.7547),
+    (50.6605, 24.9998),
+    (50.5273, 25.3278),
+    (50.2398, 25.6080),
+    (50.1133, 25.9439),
+    (50.2129, 26.2770),
+    (50.1524, 26.6896),
+    (49.4709, 27.1099),
+    (49.2995, 27.4612),
+    (48.8075, 27.6896),
+    (48.4160, 28.5520),
+    (48.0939, 29.3062),
+    (48.1831, 29.5344),
+    (47.9745, 29.9758),
+    (48.5679, 29.9267),
+    (48.9413, 30.3170),
+    (49.5768, 29.9857),
+    (50.1150, 30.1477),
+    (50.8529, 28.8145),
+    (51.5207, 27.8656),
+    (52.4835, 27.5808),
+    (53.4930, 26.8123),
+    (54.7150, 26.4806),
+    (55.7237, 26.9646),
+    (56.4921, 27.1433),
+    (56.9707, 26.9661),
+    (57.3972, 25.7399),
+    (58.5257, 25.6099),
+    (59.6161, 25.3801),
+    (61.4973, 25.0782),
+    (62.9057, 25.2184),
+    (64.5304, 25.2370),
+    (66.3728, 25.4251),
+    (67.1454, 24.6636),
+    (67.4436, 23.9448),
+    (68.1766, 23.6919),
+    (69.3495, 22.8431),
+    (69.6449, 22.4507),
+    (69.1641, 22.0892),
+    (70.4704, 20.8773),
+    (71.1752, 20.7574),
+    (72.6305, 21.3560),
+    (72.8244, 20.4195),
+    (72.8209, 19.2082),
+    (73.1199, 17.9285),
+    (73.5341, 15.9906),
+    (74.4438, 14.6172),
+    (74.6167, 13.9925),
+    (74.8648, 12.7419),
+    (75.3961, 11.7812),
+    (75.7464, 11.3082),
+    (76.1300, 10.2996),
+    (76.5929, 8.8992),
+    (77.5398, 7.9655),
+    (77.9411, 8.2529),
+    (78.2779, 8.9330),
+    (79.1897, 9.2165),
+    (78.8853, 9.5461),
+    (79.3405, 10.3088),
+    (79.8579, 10.3572),
+    (79.8625, 12.0562),
+    (80.2862, 13.0062),
+    (80.2332, 13.8357),
+    (80.0250, 15.1364),
+    (80.3248, 15.8991),
+    (80.7919, 15.9519),
+    (81.6927, 16.3102),
+    (82.1912, 16.5566),
+    (82.1927, 17.0166),
+    (83.1892, 17.6712),
+    (83.9410, 18.3020),
+    (85.0602, 19.4785),
+    (86.4993, 20.1516),
+    (87.0331, 20.7433),
+    (86.9757, 21.4955),
+    (88.2084, 21.7031),
+    (88.8887, 21.6905),
+    (89.0319, 22.0557),
+    (89.4188, 21.9661),
+    (89.7020, 21.8571),
+    (89.8474, 22.0391),
+    (90.2729, 21.8363),
+    (90.5869, 22.3927),
+    (90.4960, 22.8050),
+    (91.4170, 22.7650),
+    (91.8348, 22.1829),
+    (92.0252, 21.7015),
+    (92.0828, 21.1921),
+    (92.3685, 20.6708),
+    (93.0782, 19.8551),
+    (93.6632, 19.7269),
+    (93.5409, 19.3664),
+    (94.3248, 18.2135),
+    (94.5334, 17.2772),
+    (94.1888, 16.0379),
+    (94.8084, 15.8034),
+    (95.3693, 15.7143),
+    (96.5057, 16.4272),
+    (97.1645, 16.9287),
+    (97.5970, 16.1005),
+    (97.7777, 14.8372),
+    (98.1036, 13.6404),
+    (98.5095, 13.1223),
+    (98.4283, 12.0329),
+    (98.7645, 11.4412),
+    (98.4571, 10.6752),
+    (98.5535, 9.9329),
+    (98.2591, 8.9739),
+    (98.1500, 8.3500),
+    (98.3396, 7.7945),
+    (98.5037, 8.3823),
+    (98.9882, 7.9079),
+    (99.5196, 7.3434),
+    (99.6906, 6.8482),
+    (100.0857, 6.4644),
+    (100.3062, 6.0405),
+    (100.1967, 5.3124),
+    (100.5574, 4.7672),
+    (100.6954, 3.9391),
+    (101.2735, 3.2702),
+    (101.3906, 2.7608),
+    (102.5736, 1.9671),
+    (103.5197, 1.2263),
+    (104.2288, 1.2930),
+    (104.2479, 1.6311),
+    (103.8546, 2.5154),
+    (103.5024, 2.7910),
+    (103.4294, 3.3828),
+    (103.3321, 3.7266),
+    (103.4385, 4.1816),
+    (103.3812, 4.8550),
+    (102.9617, 5.5244),
+    (102.3711, 6.1282),
+    (102.1411, 6.2216),
+    (101.6230, 6.7406),
+    (101.0173, 6.8568),
+    (100.4592, 7.4295),
+    (100.2796, 8.2951),
+    (99.8738, 9.2078),
+    (99.2223, 9.2392),
+    (99.1537, 9.9630),
+    (99.4789, 10.8463),
+    (100.0187, 12.3070),
+    (100.0977, 13.4068),
+    (100.9784, 13.4127),
+    (100.8318, 12.6270),
+    (101.6871, 12.6457),
+    (102.5849, 12.1865),
+    (103.0906, 11.1536),
+    (103.4972, 10.6325),
+    (104.3343, 10.4865),
+    (105.0762, 9.9184),
+    (104.7951, 9.2410),
+    (105.1582, 8.5997),
+    (106.4051, 9.5308),
+    (107.2209, 10.3644),
+    (108.3661, 11.0083),
+    (109.2001, 11.6668),
+    (109.3352, 13.4260),
+    (108.8771, 15.2766),
+    (108.2694, 16.0797),
+    (107.3619, 16.6974),
+    (106.4268, 18.0041),
+    (105.6620, 19.0581),
+    (105.8816, 19.7520),
+    (106.7150, 20.6968),
+    (108.0501, 21.5523),
+    (108.5228, 21.7152),
+    (109.8644, 21.3950),
+    (109.6276, 21.0082),
+    (109.8898, 20.2824),
+    (110.4440, 20.3410),
+    (110.5093, 20.5654),
+    (110.7854, 21.3971),
+    (111.8435, 21.5504),
+    (113.2410, 22.0513),
+    (113.8067, 22.5483),
+    (114.1525, 22.2237),
+    (114.7638, 22.6680),
+    (115.8907, 22.7828),
+    (117.2816, 23.6245),
+    (118.6568, 24.5473),
+    (119.5854, 25.7407),
+    (120.3954, 27.0532),
+    (121.1256, 28.1356),
+    (121.6844, 28.2255),
+    (121.9384, 29.0180),
+    (122.0921, 29.8325),
+    (121.5035, 30.1429),
+    (121.2642, 30.6762),
+    (121.8919, 30.9493),
+    (121.9081, 31.6921),
+    (121.2290, 32.4603),
+    (120.6203, 33.3767),
+    (120.2275, 34.3603),
+    (119.1512, 34.9098),
+    (119.6645, 35.6097),
+    (120.6370, 36.1114),
+    (121.1041, 36.6513),
+    (122.5199, 36.9306),
+    (122.3579, 37.4544),
+    (121.7112, 37.4811),
+    (120.8234, 37.8704),
+    (119.7028, 37.1563),
+    (118.9116, 37.4484),
+    (118.8781, 37.8973),
+    (118.0596, 38.0614),
+    (117.5327, 38.7376),
+    (118.0427, 39.2042),
+    (119.0234, 39.2523),
+    (119.6396, 39.8980),
+    (120.7686, 40.5933),
+    (121.6403, 40.9463),
+    (122.1685, 40.4224),
+    (121.3767, 39.7502),
+    (121.5859, 39.3608),
+    (121.0545, 38.8974),
+    (122.1313, 39.1704),
+    (122.8675, 39.6377),
+    (124.2656, 39.9284),
+    (124.7374, 39.6603),
+    (125.3211, 39.5513),
+    (125.3865, 39.3879),
+    (125.1328, 38.8485),
+    (125.2219, 38.6658),
+    (124.9859, 38.5484),
+    (124.7121, 38.1083),
+    (124.9810, 37.9488),
+    (125.2400, 37.8572),
+    (125.2753, 37.6690),
+    (125.5684, 37.7520),
+    (125.6891, 37.9400),
+    (126.1747, 37.7496),
+    (126.8601, 36.8939),
+    (126.1173, 36.7254),
+    (126.5592, 35.6845),
+    (126.3739, 34.9345),
+    (126.4857, 34.3900),
+    (127.3865, 34.4756),
+    (128.1858, 34.8903),
+    (129.0913, 35.0824),
+    (129.4683, 35.6321),
+    (129.4604, 36.7841),
+    (129.2129, 37.4323),
+    (128.3497, 38.6122),
+    (127.7833, 39.0508),
+    (127.3854, 39.2134),
+    (127.5021, 39.3239),
+    (127.5334, 39.7568),
+    (127.9674, 40.0254),
+    (128.6333, 40.1898),
+    (129.0103, 40.4854),
+    (129.1881, 40.6618),
+    (129.7051, 40.8828),
+    (129.6673, 41.6011),
+    (129.9659, 41.9413),
+    (130.4000, 42.2800),
+    (130.7800, 42.2200),
+    (130.9358, 42.5527),
+    (132.2780, 43.2845),
+    (132.9062, 42.7984),
+    (133.5368, 42.8114),
+    (134.8694, 43.3982),
+    (135.5153, 43.9889),
+    (136.8623, 45.1434),
+    (138.2197, 46.3079),
+    (138.5547, 46.9996),
+    (140.0619, 48.4467),
+    (140.5130, 50.0455),
+    (140.5974, 51.2396),
+    (141.3792, 52.2387),
+    (141.3453, 53.0895),
+    (139.9015, 54.1896),
+    (138.8046, 54.2545),
+    (138.1647, 53.7550),
+    (137.1934, 53.9773),
+    (136.7017, 54.6035),
+    (135.1261, 54.7295),
+    (138.9584, 57.0880),
+    (142.1978, 59.0399),
+    (145.4872, 59.3363),
+    (148.5448, 59.1644),
+    (149.7837, 59.6557),
+    (151.3381, 59.5039),
+    (151.2657, 58.7808),
+    (152.8118, 58.8838),
+    (155.0437, 59.1449),
+    (154.2180, 59.7581),
+    (156.7206, 61.4344),
+    (159.3023, 61.7739),
+    (160.1214, 60.5442),
+    (162.6579, 61.6424),
+    (163.2583, 62.4662),
+    (164.4735, 62.5506),
+    (163.6696, 61.1408),
+    (161.87204, 60.343),
+    (160.1506, 59.3147),
+    (158.3643, 58.0557),
+    (156.8103, 57.8320),
+    (156.7581, 57.3647),
+    (155.9144, 56.7679),
+    (155.4336, 55.3810),
+    (155.9918, 53.1589),
+    (156.42, 51.7),
+    (156.7897, 51.0110),
+    (158.2311, 51.9426),
+    (158.5309, 52.9586),
+    (160.0217, 53.2025),
+    (160.3687, 54.3443),
+    (162.1174, 54.8551),
+    (161.7014, 55.2856),
+    (162.1263, 56.1158),
+    (163.0579, 56.1592),
+    (163.1919, 57.6150),
+    (162.0529, 57.8391),
+    (162.0173, 58.2432),
+    (163.2171, 59.2110),
+    (163.5392, 59.8686),
+    (164.8767, 59.7316),
+    (165.84, 60.16),
+    (166.2949, 59.7885),
+    (168.9004, 60.5735),
+    (170.3308, 59.8817),
+    (170.6985, 60.3361),
+    (172.15, 60.95),
+    (173.6801, 61.6526),
+    (174.5692, 61.7691),
+    (177.3643, 62.5219),
+    (179.2282, 62.3041),
+    (179.4863, 62.5689),
+    (179.3703, 62.9826),
+    (178.9082, 63.2519),
+    (178.313, 64.07593),
+    (177.4112, 64.6082),
+    (178.7072, 64.5349),
+    (180.0, 64.9797),
+    (-177.5500, 68.1999),
+    (-179.9999, 68.9636),
+    (-179.9999, -16.0671),
+    (-179.7933, -16.0208),
+    (-179.9173, -16.5017),
+    (-179.9999, -16.5552),
+    (125.9470, -8.4320),
+    (126.6447, -8.3982),
+    (126.9572, -8.2733),
+    (127.3359, -8.3973),
+    (126.9679, -8.6682),
+    (125.9258, -9.1060),
+    (125.0885, -9.3931),
+    (124.4359, -10.1400),
+    (123.5799, -10.3599),
+    (123.4599, -10.2399),
+    (123.5500, -9.9000),
+    (123.9800, -9.2900),
+    (124.9686, -8.8927),
+    (125.0862, -8.6568),
+    (125.9470, -8.4320),
+    (-180.0, 68.9636),
+    (-177.5500, 68.1999),
+    (-174.9282, 67.2058),
+    (-175.0142, 66.5843),
+    (-174.3398, 66.3355),
+    (-174.5718, 67.0621),
+    (-171.8573, 66.9130),
+    (-169.8995, 65.9772),
+    (-170.8910, 65.5413),
+    (-172.5302, 65.4379),
+    (-172.555, 64.46079),
+    (-172.9553, 64.2526),
+    (-173.8918, 64.2826),
+    (-174.6539, 64.6312),
+    (-175.9835, 64.9228),
+    (-176.2071, 65.3566),
+    (-177.2226, 65.5202),
+    (-178.3599, 65.3905),
+    (-178.9033, 65.7404),
+    (-178.6861, 66.1121),
+    (-179.8837, 65.8745),
+    (-179.4326, 65.4041),
+    (-180.0, 64.9797),
+    (-180.0, 71.5157),
+    (-179.8718, 71.5576),
+    (-179.0243, 71.5555),
+    (-177.5779, 71.2694),
+    (-177.6635, 71.1327),
+    (-178.6937, 70.8930),
+    (-180.0, 70.8321),
+    (180.0, 70.8321),
+    (178.9034, 70.7811),
+    (178.7253, 71.0988),
+    (180.0, 71.5157),
+    (180.0, -16.5552),
+    (179.3641, -16.8013),
+    (178.7250, -17.0120),
+    (178.5968, -16.6391),
+    (179.0966, -16.4339),
+    (179.4135, -16.3790),
+    (180.0, -16.0671),
+    (-61.2, -51.85),
+    (-60.0, -51.25),
+    (-59.15, -51.5),
+    (-58.55, -51.1),
+    (-57.75, -51.55),
+    (-58.05, -51.9),
+    (-59.4, -52.2),
+    (-59.85, -51.85),
+    (-60.7, -52.3),
+    (-61.2, -51.85),
+    (68.935, -48.625),
+    (69.58, -48.94),
+    (70.525, -49.065),
+    (70.56, -49.255),
+    (70.28, -49.71),
+    (68.745, -49.775),
+    (68.72, -49.2425),
+    (68.8675, -48.83),
+    (68.935, -48.625),
+    (178.1255, -17.5048),
+    (178.3736, -17.3399),
+    (178.7180, -17.6284),
+    (178.5527, -18.1505),
+    (177.9326, -18.2879),
+    (177.3814, -18.1643),
+    (177.2850, -17.7246),
+    (177.6708, -17.3811),
+    (178.1255, -17.5048),
+    (-61.68, 10.76),
+    (-61.105, 10.89),
+    (-60.895, 10.855),
+    (-60.935, 10.11),
+    (-61.77, 10.0),
+    (-61.95, 10.09),
+    (-61.66, 10.365),
+    (-61.68, 10.76),
+    (-155.4021, 20.0797),
+    (-155.2245, 19.9930),
+    (-155.0622, 19.8591),
+    (-154.8074, 19.5087),
+    (-154.8314, 19.4532),
+    (-155.2221, 19.2397),
+    (-155.5421, 19.0834),
+    (-155.6881, 18.9161),
+    (-155.9366, 19.0593),
+    (-155.9080, 19.3388),
+    (-156.0734, 19.7029),
+    (-156.0236, 19.8142),
+    (-155.8500, 19.9772),
+    (-155.9190, 20.1739),
+    (-155.8610, 20.2672),
+    (-155.7850, 20.2487),
+    (-155.4021, 20.0797),
+    (-155.9956, 20.7640),
+    (-156.0792, 20.6439),
+    (-156.4144, 20.5724),
+    (-156.58673, 20.783),
+    (-156.7016, 20.8643),
+    (-156.7105, 20.9267),
+    (-156.6125, 21.0124),
+    (-156.2571, 20.9174),
+    (-155.9956, 20.7640),
+    (-156.7582, 21.1768),
+    (-156.7893, 21.0687),
+    (-157.3252, 21.0977),
+    (-157.2502, 21.2195),
+    (-156.7582, 21.1768),
+    (-158.0252, 21.7169),
+    (-157.9416, 21.6527),
+    (-157.6528, 21.3221),
+    (-157.7070, 21.2644),
+    (-157.7786, 21.2772),
+    (-158.1266, 21.3124),
+    (-158.2538, 21.5391),
+    (-158.2926, 21.5791),
+    (-158.0252, 21.7169),
+    (-159.3656, 22.2149),
+    (-159.34512, 21.982),
+    (-159.4637, 21.8829),
+    (-159.8005, 22.0653),
+    (-159.7487, 22.1382),
+    (-159.5962, 22.2361),
+    (-159.3656, 22.2149),
+    (-78.1908, 25.2103),
+    (-77.89, 25.17),
+    (-77.54, 24.34),
+    (-77.5346, 23.7597),
+    (-77.78, 23.71),
+    (-78.0340, 24.2861),
+    (-78.4084, 24.5756),
+    (-78.1908, 25.2103),
+    (-78.98, 26.79),
+    (-78.51, 26.87),
+    (-77.85, 26.84),
+    (-77.82, 26.58),
+    (-78.91, 26.42),
+    (-78.98, 26.79),
+    (-77.79, 27.04),
+    (-77.0, 26.59),
+    (-77.1725, 25.8791),
+    (-77.3564, 26.0073),
+    (-77.34, 26.53),
+    (-77.7880, 26.9251),
+    (-77.79, 27.04),
+    (-64.0148, 47.0360),
+    (-63.6645, 46.5500),
+    (-62.9393, 46.4158),
+    (-62.0120, 46.4431),
+    (-62.5039, 46.0333),
+    (-62.8743, 45.9681),
+    (-64.1428, 46.3926),
+    (-64.3926, 46.7274),
+    (-64.0148, 47.0360),
+    (46.6820, 44.6092),
+    (47.6759, 45.6414),
+    (48.6454, 45.8062),
+    (49.1011, 46.3993),
+    (50.0340, 46.6089),
+    (51.1919, 47.0487),
+    (52.0420, 46.8046),
+    (53.0427, 46.8530),
+    (53.2208, 46.2346),
+    (53.0408, 45.2590),
+    (52.1673, 45.4083),
+    (51.3168, 45.2459),
+    (51.2785, 44.5148),
+    (50.3056, 44.6098),
+    (50.3391, 44.2840),
+    (50.8912, 44.0310),
+    (51.3424, 43.1329),
+    (52.5014, 42.7922),
+    (52.6921, 42.4438),
+    (52.4463, 42.0271),
+    (52.5024, 41.7833),
+    (52.8146, 41.1353),
+    (52.9167, 41.8681),
+    (53.7217, 42.1231),
+    (54.0083, 41.5512),
+    (54.7368, 40.9510),
+    (53.8581, 40.6310),
+    (52.9152, 40.8765),
+    (52.6939, 40.0336),
+    (53.3578, 39.9752),
+    (53.1010, 39.2905),
+    (53.8809, 38.9520),
+    (53.7355, 37.9061),
+    (53.9215, 37.1989),
+    (53.8257, 36.9650),
+    (52.2640, 36.7004),
+    (50.8423, 36.8728),
+    (50.1477, 37.3745),
+    (49.1996, 37.5828),
+    (48.8832, 38.3202),
+    (48.8565, 38.8154),
+    (49.2232, 39.0492),
+    (49.3952, 39.3994),
+    (49.5692, 40.1761),
+    (50.3928, 40.2565),
+    (50.0848, 40.5261),
+    (49.6189, 40.5729),
+    (49.1102, 41.2822),
+    (48.5843, 41.8088),
+    (47.4925, 42.9865),
+    (47.5909, 43.6601),
+    (46.6820, 44.6092),
+    (-64.5191, 49.8730),
+    (-64.1732, 49.9571),
+    (-62.8582, 49.7064),
+    (-61.8355, 49.2885),
+    (-61.8063, 49.1050),
+    (-62.2931, 49.0871),
+    (-63.5892, 49.4006),
+    (-64.5191, 49.8730),
+    (-80.3153, 62.0855),
+    (-79.9293, 62.3856),
+    (-79.5200, 62.3637),
+    (-79.2658, 62.1586),
+    (-79.6575, 61.6330),
+    (-80.0995, 61.7181),
+    (-80.3621, 62.0164),
+    (-80.3153, 62.0855),
+    (-83.9936, 62.4528),
+    (-83.2504, 62.9140),
+    (-81.8769, 62.9045),
+    (-81.8982, 62.7108),
+    (-83.0685, 62.1592),
+    (-83.7746, 62.1823),
+    (-83.9936, 62.4528),
+    (-75.2159, 67.4442),
+    (-75.8658, 67.1488),
+    (-76.9868, 67.0987),
+    (-77.2364, 67.5880),
+    (-76.8116, 68.1485),
+    (-75.8952, 68.2872),
+    (-75.1145, 68.0103),
+    (-75.1033, 67.5820),
+    (-75.2159, 67.4442),
+    (-96.5574, 69.6800),
+    (-95.6476, 69.1076),
+    (-96.2695, 68.7570),
+    (-97.6174, 69.0600),
+    (-98.4318, 68.9507),
+    (-99.7974, 69.4000),
+    (-98.9174, 69.7100),
+    (-98.2182, 70.1435),
+    (-97.1574, 69.8600),
+    (-96.5574, 69.6800),
+    (-106.5225, 73.0760),
+    (-105.4024, 72.6725),
+    (-104.7748, 71.6984),
+    (-104.4647, 70.9929),
+    (-102.7853, 70.4977),
+    (-100.9807, 70.0243),
+    (-101.0893, 69.5844),
+    (-102.7311, 69.5040),
+    (-102.0932, 69.1196),
+    (-102.4302, 68.7528),
+    (-104.24, 68.91),
+    (-105.96, 69.18),
+    (-107.1225, 69.1192),
+    (-109.0, 68.78),
+    (-111.5341, 68.6300),
+    (-113.3132, 68.5355),
+    (-113.8549, 69.0074),
+    (-115.22, 69.28),
+    (-116.1079, 69.1682),
+    (-117.34, 69.96),
+    (-116.6747, 70.0665),
+    (-115.1311, 70.2373),
+    (-113.7213, 70.1923),
+    (-112.4161, 70.3663),
+    (-114.3499, 70.6000),
+    (-116.4868, 70.5204),
+    (-117.9048, 70.5405),
+    (-118.4323, 70.9092),
+    (-116.1131, 71.3091),
+    (-117.6556, 71.2951),
+    (-119.4019, 71.5585),
+    (-118.5626, 72.3078),
+    (-117.8664, 72.7059),
+    (-115.1890, 73.3145),
+    (-114.1671, 73.1214),
+    (-114.6663, 72.6527),
+    (-112.4410, 72.9553),
+    (-111.0503, 72.4504),
+    (-109.9203, 72.9611),
+    (-109.0065, 72.6333),
+    (-108.1883, 71.6508),
+    (-107.6859, 72.0654),
+    (-108.3964, 73.0895),
+    (-107.5164, 73.2359),
+    (-106.5225, 73.0760),
+    (-79.7758, 72.8029),
+    (-80.8760, 73.3331),
+    (-80.8338, 73.6931),
+    (-80.3530, 73.7597),
+    (-78.0644, 73.6519),
+    (-76.34, 73.1026),
+    (-76.2514, 72.8263),
+    (-77.3144, 72.8555),
+    (-78.3916, 72.8766),
+    (-79.4862, 72.7422),
+    (-79.7758, 72.8029),
+    (139.8631, 73.3698),
+    (140.8117, 73.7650),
+    (142.0620, 73.8575),
+    (143.4828, 73.4752),
+    (143.6038, 73.2124),
+    (142.0876, 73.2054),
+    (140.0381, 73.3169),
+    (139.8631, 73.3698),
+    (148.2222, 75.3458),
+    (150.7316, 75.0840),
+    (149.5759, 74.6889),
+    (147.9774, 74.7783),
+    (146.1191, 75.1729),
+    (146.3584, 75.4968),
+    (148.2222, 75.3458),
+    (138.8310, 76.1367),
+    (141.4716, 76.0928),
+    (145.0862, 75.5626),
+    (144.3, 74.82),
+    (140.6138, 74.8476),
+    (138.9554, 74.6114),
+    (136.9743, 75.2616),
+    (137.5117, 75.9491),
+    (138.8310, 76.1367),
+    (-98.5770, 76.5886),
+    (-98.5, 76.72),
+    (-97.7355, 76.2565),
+    (-97.7044, 75.7434),
+    (-98.16, 75.0),
+    (-99.8087, 74.8974),
+    (-100.8836, 75.0573),
+    (-100.8629, 75.6407),
+    (-102.5020, 75.5638),
+    (-102.5655, 76.3365),
+    (-101.4897, 76.3053),
+    (-99.9834, 76.6463),
+    (-98.5770, 76.5886),
+    (102.8378, 79.2812),
+    (105.3724, 78.7133),
+    (105.0754, 78.3068),
+    (99.43814, 77.921),
+    (101.2649, 79.2339),
+    (102.0863, 79.3464),
+    (102.8378, 79.2812),
+    (93.7776, 81.0246),
+    (95.9408, 81.2504),
+    (97.8838, 80.7469),
+    (100.1866, 79.7801),
+    (99.9397, 78.8809),
+    (97.7579, 78.7562),
+    (94.9725, 79.0447),
+    (93.3128, 79.4265),
+    (92.5454, 80.1437),
+    (91.1810, 80.3414),
+    (93.7776, 81.0246),
+    (-96.0164, 80.6023),
+    (-95.3234, 80.9072),
+    (-94.2984, 80.9772),
+    (-94.7354, 81.2064),
+    (-92.4098, 81.2573),
+    (-91.1328, 80.7234),
+    (-87.81, 80.32),
+    (-87.02, 79.66),
+    (-85.8143, 79.3369),
+    (-87.1875, 79.0393),
+    (-89.0353, 78.2872),
+    (-90.8043, 78.2153),
+    (-92.8766, 78.3433),
+    (-93.9511, 78.7510),
+    (-93.9357, 79.1137),
+    (-93.1452, 79.3801),
+    (-94.9739, 79.3724),
+    (-96.0761, 79.7050),
+    (-96.7097, 80.1577),
+    (-96.0164, 80.6023),
+    (-91.5870, 81.8942),
+    (-90.1, 82.085),
+    (-88.9322, 82.1175),
+    (-86.9702, 82.2796),
+    (-85.5, 82.6522),
+    (-84.2600, 82.6),
+    (-83.18, 82.32),
+    (-82.42, 82.86),
+    (-81.1, 83.02),
+    (-79.3066, 83.1305),
+    (-76.25, 83.1720),
+    (-75.7187, 83.0640),
+    (-72.8315, 83.2332),
+    (-70.6657, 83.1697),
+    (-68.5, 83.1063),
+    (-65.8273, 83.0280),
+    (-63.68, 82.9),
+    (-61.85, 82.6286),
+    (-61.8938, 82.3616),
+    (-64.334, 81.92775),
+    (-66.7534, 81.7252),
+    (-67.6575, 81.5014),
+    (-65.4803, 81.5065),
+    (-67.84, 80.9),
+    (-69.4697, 80.6168),
+    (-71.18, 79.8),
+    (-73.2428, 79.6341),
+    (-73.88, 79.4301),
+    (-76.9077, 79.3230),
+    (-75.5292, 79.1976),
+    (-76.2204, 79.0190),
+    (-75.3934, 78.5258),
+    (-76.3435, 78.1829),
+    (-77.8885, 77.8999),
+    (-78.3626, 77.5085),
+    (-79.7595, 77.2096),
+    (-79.6196, 76.9833),
+    (-77.9108, 77.0220),
+    (-77.8891, 76.7779),
+    (-80.5612, 76.1781),
+    (-83.1743, 76.4540),
+    (-86.1118, 76.2990),
+    (-87.6, 76.42),
+    (-89.4906, 76.4723),
+    (-89.6161, 76.9521),
+    (-87.7673, 77.1783),
+    (-88.26, 77.9),
+    (-87.65, 77.9702),
+    (-84.9763, 77.5387),
+    (-86.34, 78.18),
+    (-87.9619, 78.3718),
+    (-87.1519, 78.7586),
+    (-85.3786, 78.9969),
+    (-85.0949, 79.3454),
+    (-86.5073, 79.7362),
+    (-86.9317, 80.2514),
+    (-84.1984, 80.2083),
+    (-83.4086, 80.1),
+    (-81.8482, 80.4644),
+    (-84.1, 80.58),
+    (-87.5989, 80.5162),
+    (-89.3666, 80.8556),
+    (-90.2, 81.26),
+    (-91.3678, 81.5531),
+    (-91.5870, 81.8942),
+    (-46.7637, 82.6279),
+    (-43.4064, 83.2251),
+    (-39.8975, 83.1801),
+    (-38.6221, 83.5490),
+    (-35.0878, 83.6451),
+    (-27.1004, 83.5196),
+    (-20.8453, 82.7266),
+    (-22.6918, 82.3416),
+    (-26.5175, 82.2976),
+    (-31.9, 82.2),
+    (-31.3964, 82.0215),
+    (-27.8566, 82.1317),
+    (-24.8444, 81.7869),
+    (-22.9032, 82.0931),
+    (-22.0717, 81.7344),
+    (-23.1696, 81.1527),
+    (-20.6236, 81.5246),
+    (-15.7681, 81.9124),
+    (-12.7701, 81.7188),
+    (-12.2085, 81.2915),
+    (-16.2853, 80.5800),
+    (-16.85, 80.35),
+    (-20.0462, 80.1770),
+    (-17.7303, 80.1291),
+    (-18.9, 79.4),
+    (-19.7049, 78.7512),
+    (-19.6735, 77.6385),
+    (-18.4728, 76.9856),
+    (-20.0350, 76.9443),
+    (-21.6794, 76.6279),
+    (-19.8340, 76.0980),
+    (-19.5989, 75.2483),
+    (-20.6681, 75.1558),
+    (-19.3728, 74.2956),
+    (-21.5942, 74.2238),
+    (-20.4345, 73.8171),
+    (-20.7623, 73.4643),
+    (-22.1722, 73.3095),
+    (-23.5659, 73.3066),
+    (-22.3131, 72.6292),
+    (-22.2995, 72.1840),
+    (-24.2783, 72.5978),
+    (-24.7929, 72.3302),
+    (-23.4429, 72.0801),
+    (-22.1328, 71.4689),
+    (-21.7535, 70.6636),
+    (-23.53603, 70.471),
+    (-24.3070, 70.8564),
+    (-25.5434, 71.4309),
+    (-25.2013, 70.7522),
+    (-26.3627, 70.2264),
+    (-23.7274, 70.1840),
+    (-22.3490, 70.1294),
+    (-25.0292, 69.2588),
+    (-27.7473, 68.4704),
+    (-30.6737, 68.1250),
+    (-31.7766, 68.1207),
+    (-32.8110, 67.7354),
+    (-34.2019, 66.6797),
+    (-36.3528, 65.9789),
+    (-37.0437, 65.9376),
+    (-38.3750, 65.6921),
+    (-39.8122, 65.4584),
+    (-40.6689, 64.8399),
+    (-40.6828, 64.1390),
+    (-41.1887, 63.4824),
+    (-42.8193, 62.6823),
+    (-42.4166, 61.9009),
+    (-42.8661, 61.0740),
+    (-43.3784, 60.0977),
+    (-44.7875, 60.0367),
+    (-46.2636, 60.8532),
+    (-48.2629, 60.8584),
+    (-49.2330, 61.4068),
+    (-49.9003, 62.3833),
+    (-51.6332, 63.6269),
+    (-52.1401, 64.2784),
+    (-52.2765, 65.1767),
+    (-53.6616, 66.0995),
+    (-53.3016, 66.8365),
+    (-53.9691, 67.1889),
+    (-52.9804, 68.3575),
+    (-51.4753, 68.7295),
+    (-51.0804, 69.1478),
+    (-50.8712, 69.9291),
+    (-52.0135, 69.5749),
+    (-52.5579, 69.4261),
+    (-53.4562, 69.2836),
+    (-54.6833, 69.6100),
+    (-54.7500, 70.2893),
+    (-54.3588, 70.8213),
+    (-53.4313, 70.8357),
+    (-51.3901, 70.5697),
+    (-53.1093, 71.2048),
+    (-54.0042, 71.5471),
+    (-55.0, 71.4065),
+    (-55.8346, 71.6544),
+    (-54.7181, 72.5862),
+    (-55.3263, 72.9586),
+    (-56.1200, 73.6497),
+    (-57.3236, 74.7102),
+    (-58.5967, 75.0986),
+    (-58.5851, 75.5172),
+    (-61.2686, 76.1023),
+    (-63.3916, 76.1752),
+    (-66.0642, 76.1348),
+    (-68.5043, 76.0614),
+    (-69.6648, 76.3797),
+    (-71.4025, 77.0085),
+    (-68.7767, 77.3231),
+    (-66.7639, 77.3759),
+    (-71.0429, 77.6359),
+    (-73.297, 78.04419),
+    (-73.1593, 78.4327),
+    (-69.3734, 78.9138),
+    (-65.7107, 79.3943),
+    (-65.3239, 79.7581),
+    (-68.0229, 80.1172),
+    (-67.1512, 80.5158),
+    (-63.6892, 81.2139),
+    (-62.2344, 81.3211),
+    (-62.6511, 81.7704),
+    (-60.2824, 82.0336),
+    (-57.2074, 82.1907),
+    (-54.1344, 82.1996),
+    (-53.0432, 81.8883),
+    (-50.3906, 82.4388),
+    (-48.0038, 82.0648),
+    (-46.5998, 81.9859),
+    (-44.523, 81.6607),
+    (-46.9007, 82.1997),
+    (-46.7637, 82.6279),
+    (-106.6, 73.6),
+    (-105.26, 73.64),
+    (-104.5, 73.42),
+    (-105.38, 72.76),
+    (-106.94, 73.46),
+    (-106.6, 73.6),
+    (-180.0, -84.71338),
+    (-179.9424, -84.7214),
+    (-179.0586, -84.1394),
+    (-177.2567, -84.4529),
+    (-176.0846, -84.0992),
+    (-175.8298, -84.1179),
+    (-174.3825, -84.5343),
+    (-173.1165, -84.1179),
+    (-172.8891, -84.0610),
+    (-169.9512, -83.8846),
+    (-168.9999, -84.1179),
+    (-168.5301, -84.2373),
+    (-167.0220, -84.5704),
+    (-164.1821, -84.8252),
+    (-161.9297, -85.1387),
+    (-158.0713, -85.3739),
+    (-155.1922, -85.0995),
+    (-150.9420, -85.2955),
+    (-148.5330, -85.6090),
+    (-145.8889, -85.3151),
+    (-143.1077, -85.0407),
+    (-142.8922, -84.5704),
+    (-146.8290, -84.5312),
+    (-150.0607, -84.2961),
+    (-150.9029, -83.9042),
+    (-153.5862, -83.6886),
+    (-153.4099, -83.2380),
+    (-153.0377, -82.8265),
+    (-152.6656, -82.4541),
+    (-152.8615, -82.0426),
+    (-154.5262, -81.7683),
+    (-155.2901, -81.4156),
+    (-156.8374, -81.1021),
+    (-154.4087, -81.1609),
+    (-152.0976, -81.0041),
+    (-150.6482, -81.3373),
+    (-148.8659, -81.0433),
+    (-147.2207, -80.6710),
+    (-146.4177, -80.3379),
+    (-146.7702, -79.9264),
+    (-148.0629, -79.6520),
+    (-149.5319, -79.3582),
+    (-151.5884, -79.2993),
+    (-153.3903, -79.1622),
+    (-155.3293, -79.0642),
+    (-155.9756, -78.6919),
+    (-157.2683, -78.3784),
+    (-158.0517, -78.0256),
+    (-158.3651, -76.8892),
+    (-157.8754, -76.9872),
+    (-156.9745, -77.3007),
+    (-155.3293, -77.2027),
+    (-153.7428, -77.0655),
+    (-152.9202, -77.4966),
+    (-151.3337, -77.3987),
+    (-150.0019, -77.1831),
+    (-148.7484, -76.9088),
+    (-147.6124, -76.5757),
+    (-146.1044, -76.4777),
+    (-146.1435, -76.1054),
+    (-146.4960, -75.7331),
+    (-146.2023, -75.3804),
+    (-144.9096, -75.2040),
+    (-144.3220, -75.5371),
+    (-142.7943, -75.3412),
+    (-141.6387, -75.0864),
+    (-140.2090, -75.0668),
+    (-138.8575, -74.9689),
+    (-137.5062, -74.7337),
+    (-136.4289, -74.5182),
+    (-135.2145, -74.3026),
+    (-134.4311, -74.3614),
+    (-133.7456, -74.4398),
+    (-132.2571, -74.3026),
+    (-130.9253, -74.4790),
+    (-129.5542, -74.4594),
+    (-128.2420, -74.3222),
+    (-126.8906, -74.4202),
+    (-125.4020, -74.5182),
+    (-124.0114, -74.4790),
+    (-122.5621, -74.4986),
+    (-121.0736, -74.5182),
+    (-119.7025, -74.4790),
+    (-118.6841, -74.1850),
+    (-117.4698, -74.0283),
+    (-116.2163, -74.2438),
+    (-115.0215, -74.0675),
+    (-113.9443, -73.7148),
+    (-113.2979, -74.0283),
+    (-112.9454, -74.3810),
+    (-112.2990, -74.7141),
+    (-111.2610, -74.4202),
+    (-110.0663, -74.7925),
+    (-108.7149, -74.9101),
+    (-107.5593, -75.1844),
+    (-106.1491, -75.1256),
+    (-104.8760, -74.9493),
+    (-103.3679, -74.9884),
+    (-102.0165, -75.1256),
+    (-100.6455, -75.3020),
+    (-100.1166, -74.8709),
+    (-100.7630, -74.5378),
+    (-101.2527, -74.1850),
+    (-102.5453, -74.1067),
+    (-103.1133, -73.7344),
+    (-103.3287, -73.3620),
+    (-103.6812, -72.6175),
+    (-102.9174, -72.7546),
+    (-101.6052, -72.8134),
+    (-100.3125, -72.7546),
+    (-99.1373, -72.9114),
+    (-98.1188, -73.2053),
+    (-97.6880, -73.5580),
+    (-96.3365, -73.6168),
+    (-95.0439, -73.4797),
+    (-93.6729, -73.2837),
+    (-92.4390, -73.1661),
+    (-91.4205, -73.4013),
+    (-90.0887, -73.3229),
+    (-89.2269, -72.5587),
+    (-88.4239, -73.0093),
+    (-87.2683, -73.1857),
+    (-86.0148, -73.0877),
+    (-85.1922, -73.4797),
+    (-83.8799, -73.5188),
+    (-82.6656, -73.6364),
+    (-81.4709, -73.8519),
+    (-80.6874, -73.4797),
+    (-80.2957, -73.1269),
+    (-79.2968, -73.5188),
+    (-77.9258, -73.4208),
+    (-76.9073, -73.6364),
+    (-76.2218, -73.9695),
+    (-74.8900, -73.8716),
+    (-73.8520, -73.6560),
+    (-72.8335, -73.4013),
+    (-71.6192, -73.2641),
+    (-70.2090, -73.1465),
+    (-68.9359, -73.0093),
+    (-67.9566, -72.7938),
+    (-67.3690, -72.4803),
+    (-67.1340, -72.0492),
+    (-67.2515, -71.6377),
+    (-67.5649, -71.2458),
+    (-67.9174, -70.8539),
+    (-68.2308, -70.4620),
+    (-68.4854, -70.1093),
+    (-68.5442, -69.7173),
+    (-68.4462, -69.3255),
+    (-67.9762, -68.9532),
+    (-67.5844, -68.5417),
+    (-67.4278, -68.1498),
+    (-67.6236, -67.7187),
+    (-67.7411, -67.3268),
+    (-67.2515, -66.8761),
+    (-66.7031, -66.5822),
+    (-66.0568, -66.2099),
+    (-65.3713, -65.8963),
+    (-64.5682, -65.6025),
+    (-64.1765, -65.1714),
+    (-63.6281, -64.8970),
+    (-63.0013, -64.6423),
+    (-62.0416, -64.5835),
+    (-61.4149, -64.2700),
+    (-60.7098, -64.0740),
+    (-59.8872, -63.9565),
+    (-59.1625, -63.7017),
+    (-58.5945, -63.3882),
+    (-57.8111, -63.2706),
+    (-57.2235, -63.5254),
+    (-57.5957, -63.8585),
+    (-58.6141, -64.1524),
+    (-59.0450, -64.3680),
+    (-59.7893, -64.2112),
+    (-60.6119, -64.3092),
+    (-61.2974, -64.5443),
+    (-62.0221, -64.7990),
+    (-62.5117, -65.0930),
+    (-62.6488, -65.4849),
+    (-62.5901, -65.8572),
+    (-62.1200, -66.1903),
+    (-62.8055, -66.4255),
+    (-63.7456, -66.5038),
+    (-64.2941, -66.8370),
+    (-64.8816, -67.1504),
+    (-65.5084, -67.5816),
+    (-65.6650, -67.9538),
+    (-65.3125, -68.3653),
+    (-64.7837, -68.6789),
+    (-63.9611, -68.9139),
+    (-63.1972, -69.2275),
+    (-62.7859, -69.6194),
+    (-62.5705, -69.9917),
+    (-62.2767, -70.3836),
+    (-61.8066, -70.7167),
+    (-61.5129, -71.0890),
+    (-61.3758, -72.0100),
+    (-61.0819, -72.3823),
+    (-61.0036, -72.7742),
+    (-60.6902, -73.1661),
+    (-60.8273, -73.6952),
+    (-61.3758, -74.1067),
+    (-61.9633, -74.4398),
+    (-63.2952, -74.5769),
+    (-63.7456, -74.9297),
+    (-64.3528, -75.2628),
+    (-65.8609, -75.6351),
+    (-67.1928, -75.7919),
+    (-68.4462, -76.0074),
+    (-69.7977, -76.2229),
+    (-70.6007, -76.6344),
+    (-72.2067, -76.6736),
+    (-73.9695, -76.6344),
+    (-75.5559, -76.7128),
+    (-77.2403, -76.7128),
+    (-76.9269, -77.1048),
+    (-75.3992, -77.2810),
+    (-74.2828, -77.5554),
+    (-73.6561, -77.9081),
+    (-74.7725, -78.2216),
+    (-76.4961, -78.1236),
+    (-77.9258, -78.3784),
+    (-77.9846, -78.7899),
+    (-78.0237, -79.1818),
+    (-76.8486, -79.5149),
+    (-76.6332, -79.8872),
+    (-75.3600, -80.2595),
+    (-73.2448, -80.4163),
+    (-71.4429, -80.6906),
+    (-70.0131, -81.0041),
+    (-68.1916, -81.3176),
+    (-65.7042, -81.4744),
+    (-63.2560, -81.7487),
+    (-61.5520, -82.0426),
+    (-59.6914, -82.3758),
+    (-58.7121, -82.8461),
+    (-58.2224, -83.2184),
+    (-57.0081, -82.8656),
+    (-55.3628, -82.5717),
+    (-53.6197, -82.2582),
+    (-51.5436, -82.0035),
+    (-49.7613, -81.7291),
+    (-47.2739, -81.7095),
+    (-44.8257, -81.8467),
+    (-42.8083, -82.0819),
+    (-42.1620, -81.6508),
+    (-40.7714, -81.3568),
+    (-38.2448, -81.3373),
+    (-36.2666, -81.1217),
+    (-34.3863, -80.9061),
+    (-32.3102, -80.7690),
+    (-30.0970, -80.5926),
+    (-28.5498, -80.3379),
+    (-29.2549, -79.9851),
+    (-29.6858, -79.6325),
+    (-29.6858, -79.2602),
+    (-31.6248, -79.2993),
+    (-33.6813, -79.4561),
+    (-35.6399, -79.4561),
+    (-35.9141, -79.0838),
+    (-35.7770, -78.3392),
+    (-35.3265, -78.1236),
+    (-33.8967, -77.8885),
+    (-32.2123, -77.6534),
+    (-30.9980, -77.3595),
+    (-29.7837, -77.0655),
+    (-28.8827, -76.6736),
+    (-27.5117, -76.4973),
+    (-26.1603, -76.3601),
+    (-25.4748, -76.2818),
+    (-23.9275, -76.2425),
+    (-22.4585, -76.1054),
+    (-21.2246, -75.9094),
+    (-20.0103, -75.6743),
+    (-18.9135, -75.4392),
+    (-17.5229, -75.1256),
+    (-16.6415, -74.7925),
+    (-15.7014, -74.4986),
+    (-15.4077, -74.1067),
+    (-16.4653, -73.8716),
+    (-16.1127, -73.4601),
+    (-15.4468, -73.1465),
+    (-14.4088, -72.9505),
+    (-13.3119, -72.7154),
+    (-12.2935, -72.4019),
+    (-11.5100, -72.0100),
+    (-11.0204, -71.5397),
+    (-10.2957, -71.2654),
+    (-9.1010, -71.3242),
+    (-8.6113, -71.6573),
+    (-7.4166, -71.6965),
+    (-7.3774, -71.3242),
+    (-6.8682, -70.9323),
+    (-5.7909, -71.0302),
+    (-5.5363, -71.4026),
+    (-4.3416, -71.4613),
+    (-3.0489, -71.2850),
+    (-1.7954, -71.1674),
+    (-0.6594, -71.2262),
+    (-0.2286, -71.6377),
+    (0.8681, -71.3046),
+    (1.8866, -71.1282),
+    (3.0226, -70.9911),
+    (4.1390, -70.8539),
+    (5.1575, -70.6187),
+    (6.2739, -70.4620),
+    (7.1357, -70.2465),
+    (7.7428, -69.8937),
+    (8.4871, -70.1485),
+    (9.5251, -70.0113),
+    (10.2498, -70.4816),
+    (10.8178, -70.8343),
+    (11.9538, -70.6383),
+    (12.4042, -70.2465),
+    (13.4227, -69.9721),
+    (14.7349, -70.0309),
+    (15.1267, -70.4032),
+    (15.9493, -70.0309),
+    (17.0265, -69.9133),
+    (18.2017, -69.8741),
+    (19.2593, -69.8937),
+    (20.3757, -70.0113),
+    (21.4529, -70.0701),
+    (21.9230, -70.4032),
+    (22.5694, -70.6971),
+    (23.6661, -70.5208),
+    (24.8413, -70.4816),
+    (25.9773, -70.4816),
+    (27.0937, -70.4620),
+    (28.0925, -70.3248),
+    (29.1502, -70.2072),
+    (30.0315, -69.9329),
+    (30.9717, -69.7566),
+    (31.9901, -69.6586),
+    (32.7540, -69.3842),
+    (33.3024, -68.8356),
+    (33.8704, -68.5025),
+    (34.9084, -68.6592),
+    (35.3002, -69.0120),
+    (36.1620, -69.2471),
+    (37.2000, -69.1687),
+    (37.9051, -69.5214),
+    (38.6494, -69.7762),
+    (39.6678, -69.5410),
+    (40.0204, -69.1099),
+    (40.9213, -68.9336),
+    (41.9594, -68.6005),
+    (42.9387, -68.4633),
+    (44.1138, -68.2674),
+    (44.8972, -68.0518),
+    (45.7199, -67.8167),
+    (46.5033, -67.6011),
+    (47.4434, -67.7187),
+    (48.3444, -67.3660),
+    (48.9907, -67.0917),
+    (49.9308, -67.1113),
+    (50.7534, -66.8761),
+    (50.9493, -66.5234),
+    (51.7915, -66.2491),
+    (52.6141, -66.0531),
+    (53.6130, -65.8963),
+    (54.5335, -65.8180),
+    (55.4149, -65.8768),
+    (56.3550, -65.9747),
+    (57.1580, -66.2491),
+    (57.2559, -66.6802),
+    (58.1373, -67.0133),
+    (58.7445, -67.2876),
+    (59.9393, -67.4052),
+    (60.6052, -67.6795),
+    (61.4278, -67.9538),
+    (62.3874, -68.0126),
+    (63.1904, -67.8167),
+    (64.0523, -67.4052),
+    (64.9924, -67.6207),
+    (65.9717, -67.7383),
+    (66.9118, -67.8559),
+    (67.8911, -67.9343),
+    (68.8900, -67.9343),
+    (69.7126, -68.9727),
+    (69.6734, -69.2275),
+    (69.5559, -69.6782),
+    (68.5962, -69.9329),
+    (67.8127, -70.3052),
+    (67.9498, -70.6971),
+    (69.0663, -70.6775),
+    (68.9291, -71.0694),
+    (68.4199, -71.4417),
+    (67.9498, -71.8532),
+    (68.7137, -72.1668),
+    (69.8693, -72.2647),
+    (71.0248, -72.0884),
+    (71.5732, -71.6965),
+    (71.9062, -71.3242),
+    (72.4546, -71.0107),
+    (73.0814, -70.7167),
+    (73.3360, -70.3640),
+    (73.8648, -69.8741),
+    (74.4915, -69.7762),
+    (75.6275, -69.7370),
+    (76.6264, -69.6194),
+    (77.6449, -69.4626),
+    (78.1345, -69.0707),
+    (78.4283, -68.6984),
+    (79.1138, -68.3262),
+    (80.0931, -68.0715),
+    (80.9353, -67.8755),
+    (81.4837, -67.5423),
+    (82.0517, -67.3660),
+    (82.7764, -67.2092),
+    (83.7753, -67.3072),
+    (84.6762, -67.2092),
+    (85.6555, -67.0917),
+    (86.7523, -67.1504),
+    (87.4770, -66.8761),
+    (87.9862, -66.2099),
+    (88.3584, -66.4842),
+    (88.8284, -66.9545),
+    (89.6706, -67.1504),
+    (90.6303, -67.2288),
+    (91.5900, -67.1113),
+    (92.6085, -67.1896),
+    (93.5486, -67.2092),
+    (94.1754, -67.1113),
+    (95.0175, -67.1701),
+    (95.7814, -67.3856),
+    (96.6823, -67.2485),
+    (97.7596, -67.2485),
+    (98.6802, -67.1113),
+    (99.7181, -67.2485),
+    (100.3841, -66.9153),
+    (100.8933, -66.5822),
+    (101.5788, -66.3078),
+    (102.8324, -65.5632),
+    (103.4786, -65.7004),
+    (104.2425, -65.9747),
+    (104.9084, -66.3275),
+    (106.1815, -66.9349),
+    (107.1608, -66.9545),
+    (108.0813, -66.9545),
+    (109.1586, -66.8370),
+    (110.2358, -66.6998),
+    (111.0584, -66.4255),
+    (111.7439, -66.1315),
+    (112.8603, -66.0923),
+    (113.6046, -65.8768),
+    (114.3880, -66.0727),
+    (114.8973, -66.3862),
+    (115.6023, -66.6998),
+    (116.6991, -66.6606),
+    (117.3847, -66.9153),
+    (118.5794, -67.1701),
+    (119.8329, -67.2680),
+    (120.8709, -67.1896),
+    (121.6544, -66.8761),
+    (122.3203, -66.5626),
+    (123.2212, -66.4842),
+    (124.1222, -66.6214),
+    (125.1602, -66.7193),
+    (126.1003, -66.5626),
+    (127.0014, -66.5626),
+    (127.8827, -66.6606),
+    (128.8032, -66.7586),
+    (129.7042, -66.5822),
+    (130.7814, -66.4255),
+    (131.7999, -66.3862),
+    (132.9358, -66.3862),
+    (133.8564, -66.2883),
+    (134.7573, -66.2099),
+    (135.0315, -65.7200),
+    (135.0707, -65.3085),
+    (135.6974, -65.5828),
+    (135.8738, -66.0335),
+    (136.2067, -66.4450),
+    (136.6180, -66.7781),
+    (137.4602, -66.9545),
+    (138.5962, -66.8957),
+    (139.9084, -66.8761),
+    (140.8094, -66.8173),
+    (142.1216, -66.8173),
+    (143.0618, -66.7977),
+    (144.3740, -66.8370),
+    (145.4904, -66.9153),
+    (146.1955, -67.2288),
+    (145.9996, -67.6011),
+    (146.6460, -67.8951),
+    (147.7232, -68.1302),
+    (148.8396, -68.3850),
+    (150.1323, -68.5612),
+    (151.4837, -68.7181),
+    (152.5022, -68.8748),
+    (153.6381, -68.8945),
+    (154.2845, -68.5612),
+    (155.1658, -68.8356),
+    (155.9297, -69.1492),
+    (156.8111, -69.3842),
+    (158.0255, -69.4822),
+    (159.1810, -69.5998),
+    (159.6706, -69.9917),
+    (160.8066, -70.2268),
+    (161.5704, -70.5796),
+    (162.6868, -70.7363),
+    (163.8424, -70.7167),
+    (164.9196, -70.7755),
+    (166.1144, -70.7559),
+    (167.3090, -70.8343),
+    (168.4256, -70.9714),
+    (169.4635, -71.2066),
+    (170.5016, -71.4026),
+    (171.2067, -71.6965),
+    (171.0892, -72.0884),
+    (170.5604, -72.4411),
+    (170.1099, -72.8918),
+    (169.7573, -73.2445),
+    (169.2873, -73.6560),
+    (167.9751, -73.8128),
+    (167.3874, -74.1654),
+    (166.0948, -74.3810),
+    (165.6443, -74.7729),
+    (164.9588, -75.1452),
+    (164.2341, -75.4588),
+    (163.8227, -75.8703),
+    (163.5682, -76.2425),
+    (163.4702, -76.6933),
+    (163.4898, -77.0655),
+    (164.0578, -77.4574),
+    (164.2733, -77.8297),
+    (164.7434, -78.1825),
+    (166.6041, -78.3196),
+    (166.9957, -78.7507),
+    (165.1938, -78.9074),
+    (163.6662, -79.1230),
+    (161.7663, -79.1622),
+    (160.9241, -79.7304),
+    (160.7478, -80.2007),
+    (160.3169, -80.5730),
+    (159.7882, -80.9453),
+    (161.1200, -81.2785),
+    (161.6292, -81.6900),
+    (162.4909, -82.0622),
+    (163.7053, -82.3954),
+    (165.0959, -82.7089),
+    (166.6041, -83.0224),
+    (168.8956, -83.3359),
+    (169.4047, -83.8258),
+    (172.2839, -84.0414),
+    (172.4770, -84.1179),
+    (173.2240, -84.4137),
+    (175.9856, -84.1589),
+    (178.2772, -84.4725),
+    (180.0, -84.71338),
+];
+
+pub static WORLD_LOW_RESOLUTION: [(f64, f64); 1166] = [
+    (-92.32, 48.24),
+    (-88.13, 48.92),
+    (-83.11, 46.27),
+    (-81.66, 44.76),
+    (-82.09, 42.29),
+    (-77.10, 44.00),
+    (-69.95, 46.92),
+    (-65.92, 45.32),
+    (-66.37, 44.25),
+    (-61.22, 45.43),
+    (-64.94, 47.34),
+    (-64.12, 48.52),
+    (-70.68, 47.02),
+    (-67.24, 49.33),
+    (-59.82, 50.48),
+    (-56.14, 52.46),
+    (-59.07, 53.58),
+    (-58.26, 54.21),
+    (-60.69, 55.33),
+    (-61.97, 57.41),
+    (-64.35, 59.49),
+    (-67.29, 58.15),
+    (-69.89, 59.91),
+    (-71.31, 61.45),
+    (-78.22, 61.97),
+    (-77.28, 59.53),
+    (-77.09, 55.88),
+    (-79.06, 51.68),
+    (-82.23, 52.70),
+    (-86.75, 55.72),
+    (-92.17, 56.86),
+    (-95.61, 58.82),
+    (-92.66, 62.02),
+    (-90.65, 63.24),
+    (-95.96, 64.12),
+    (-89.88, 63.98),
+    (-89.30, 65.22),
+    (-86.86, 66.12),
+    (-84.54, 66.88),
+    (-82.30, 67.76),
+    (-83.10, 69.68),
+    (-86.05, 67.98),
+    (-88.18, 68.20),
+    (-91.00, 68.82),
+    (-91.72, 69.69),
+    (-93.15, 71.09),
+    (-96.58, 71.05),
+    (-93.35, 69.52),
+    (-94.23, 68.25),
+    (-95.96, 66.73),
+    (-98.83, 68.27),
+    (-102.45, 67.69),
+    (-108.34, 68.43),
+    (-105.83, 68.05),
+    (-108.15, 66.60),
+    (-111.15, 67.63),
+    (-114.10, 68.23),
+    (-120.92, 69.44),
+    (-124.32, 69.26),
+    (-128.76, 70.50),
+    (-131.86, 69.19),
+    (-131.15, 69.79),
+    (-135.81, 69.13),
+    (-140.19, 69.37),
+    (-141.20, 69.58),
+    (-141.21, 69.56),
+    (-142.49, 69.83),
+    (-148.09, 70.26),
+    (-154.37, 70.96),
+    (-159.53, 70.38),
+    (-166.64, 68.25),
+    (-161.56, 66.55),
+    (-162.99, 65.97),
+    (-168.23, 65.49),
+    (-161.12, 64.49),
+    (-165.29, 62.57),
+    (-164.58, 60.06),
+    (-162.06, 58.36),
+    (-157.85, 58.12),
+    (-162.34, 55.06),
+    (-156.52, 57.11),
+    (-153.53, 59.32),
+    (-149.18, 60.81),
+    (-149.90, 59.50),
+    (-146.54, 60.36),
+    (-139.98, 59.73),
+    (-137.12, 58.28),
+    (-136.01, 59.12),
+    (-133.84, 57.12),
+    (-131.46, 55.98),
+    (-132.08, 57.20),
+    (-140.37, 60.25),
+    (-141.21, 60.16),
+    (-133.38, 58.93),
+    (-130.88, 54.83),
+    (-128.86, 53.90),
+    (-126.58, 52.12),
+    (-127.08, 50.80),
+    (-124.42, 49.66),
+    (-122.56, 48.91),
+    (-122.44, 48.92),
+    (-124.42, 47.18),
+    (-124.52, 42.48),
+    (-123.09, 38.45),
+    (-121.73, 36.62),
+    (-117.60, 33.34),
+    (-117.28, 32.64),
+    (-117.29, 32.48),
+    (-114.75, 27.80),
+    (-112.53, 24.80),
+    (-110.55, 24.07),
+    (-114.23, 29.59),
+    (-112.58, 29.99),
+    (-109.57, 25.94),
+    (-105.61, 21.94),
+    (-102.09, 17.87),
+    (-95.75, 15.94),
+    (-92.21, 14.97),
+    (-92.22, 14.71),
+    (-86.74, 12.06),
+    (-83.03, 8.65),
+    (-79.93, 8.74),
+    (-77.00, 7.82),
+    (-81.99, 8.97),
+    (-83.92, 12.70),
+    (-86.33, 15.80),
+    (-88.40, 15.92),
+    (-88.45, 17.42),
+    (-87.01, 21.33),
+    (-91.65, 18.72),
+    (-96.96, 20.37),
+    (-97.65, 25.67),
+    (-97.62, 25.82),
+    (-95.62, 28.84),
+    (-90.77, 29.03),
+    (-87.33, 30.22),
+    (-82.69, 28.15),
+    (-80.16, 26.66),
+    (-80.74, 32.31),
+    (-76.89, 35.43),
+    (-76.47, 38.21),
+    (-75.66, 37.67),
+    (-71.31, 41.76),
+    (-69.44, 44.17),
+    (-67.69, 47.03),
+    (-73.18, 45.14),
+    (-79.26, 43.28),
+    (-82.84, 42.59),
+    (-83.49, 45.32),
+    (-86.36, 43.65),
+    (-87.75, 43.42),
+    (-86.01, 45.96),
+    (-87.00, 46.59),
+    (-91.39, 46.79),
+    (-90.05, 47.96),
+    (-152.62, 58.41),
+    (-152.60, 58.40),
+    (-153.30, 57.80),
+    (-152.40, 57.48),
+    (-153.32, 57.79),
+    (-166.96, 53.96),
+    (-167.01, 53.95),
+    (-168.36, 53.50),
+    (-168.19, 53.36),
+    (-170.73, 52.68),
+    (-170.60, 52.55),
+    (-174.47, 51.94),
+    (-174.47, 51.92),
+    (-176.58, 51.71),
+    (-176.64, 51.73),
+    (-177.55, 51.76),
+    (-177.41, 51.63),
+    (-178.27, 51.75),
+    (177.35, 51.80),
+    (177.33, 51.76),
+    (172.44, 53.00),
+    (172.55, 53.03),
+    (-123.40, 48.33),
+    (-128.00, 50.84),
+    (-123.50, 48.34),
+    (-132.49, 52.88),
+    (-132.44, 52.91),
+    (-132.64, 53.02),
+    (-131.97, 53.71),
+    (-132.63, 53.02),
+    (-55.36, 51.56),
+    (-54.66, 49.52),
+    (-53.65, 47.48),
+    (-52.98, 46.31),
+    (-56.12, 46.84),
+    (-58.47, 47.57),
+    (-57.61, 50.38),
+    (-55.39, 51.53),
+    (-61.37, 49.01),
+    (-61.80, 49.29),
+    (-61.38, 49.03),
+    (-63.01, 46.71),
+    (-64.42, 46.61),
+    (-63.04, 46.68),
+    (-60.14, 46.48),
+    (-60.14, 46.50),
+    (-71.97, 41.11),
+    (-71.97, 41.15),
+    (-80.79, 27.03),
+    (-81.01, 26.99),
+    (-113.01, 42.09),
+    (-113.10, 42.01),
+    (-155.74, 20.02),
+    (-155.73, 19.98),
+    (-156.51, 20.78),
+    (-156.51, 20.78),
+    (-157.12, 21.21),
+    (-157.08, 20.95),
+    (-157.87, 21.42),
+    (-159.53, 22.07),
+    (-117.44, 66.46),
+    (-119.59, 65.24),
+    (-123.95, 65.03),
+    (-123.69, 66.44),
+    (-119.21, 66.22),
+    (-117.44, 66.44),
+    (-120.71, 64.03),
+    (-114.91, 62.30),
+    (-109.07, 62.72),
+    (-112.62, 61.19),
+    (-118.68, 61.19),
+    (-117.01, 61.17),
+    (-115.97, 62.56),
+    (-119.46, 64.00),
+    (-120.59, 63.94),
+    (-112.31, 58.46),
+    (-108.90, 59.44),
+    (-104.14, 58.90),
+    (-102.56, 56.72),
+    (-101.82, 58.73),
+    (-104.65, 58.91),
+    (-111.00, 58.51),
+    (-112.35, 58.62),
+    (-98.74, 50.09),
+    (-99.75, 52.24),
+    (-99.62, 51.47),
+    (-98.82, 50.39),
+    (-97.02, 50.21),
+    (-97.50, 54.02),
+    (-98.69, 52.93),
+    (-97.19, 51.09),
+    (-96.98, 50.20),
+    (-95.34, 49.04),
+    (-92.32, 50.34),
+    (-94.14, 49.47),
+    (-95.36, 48.82),
+    (-80.39, 56.16),
+    (-79.22, 55.94),
+    (-80.34, 56.08),
+    (-103.56, 58.60),
+    (-103.60, 58.58),
+    (-101.82, 58.03),
+    (-102.33, 58.10),
+    (-101.77, 58.06),
+    (-101.88, 55.79),
+    (-97.92, 57.15),
+    (-101.22, 55.85),
+    (-101.88, 55.74),
+    (-77.61, 6.80),
+    (-78.70, 0.97),
+    (-80.75, -4.47),
+    (-76.19, -14.57),
+    (-70.44, -18.75),
+    (-70.68, -26.15),
+    (-71.44, -32.03),
+    (-73.38, -37.27),
+    (-73.06, -42.11),
+    (-73.17, -46.09),
+    (-73.52, -48.05),
+    (-73.67, -51.56),
+    (-71.06, -53.88),
+    (-69.14, -50.77),
+    (-67.51, -46.59),
+    (-63.49, -42.80),
+    (-62.14, -40.16),
+    (-57.12, -36.71),
+    (-53.17, -34.15),
+    (-51.26, -32.02),
+    (-48.16, -25.48),
+    (-40.73, -22.32),
+    (-38.88, -15.24),
+    (-34.60, -7.81),
+    (-41.95, -3.42),
+    (-48.02, -1.84),
+    (-48.44, -1.57),
+    (-50.81, 0.00),
+    (-54.47, 5.39),
+    (-60.59, 8.32),
+    (-64.19, 9.88),
+    (-70.78, 10.64),
+    (-70.97, 11.89),
+    (-76.26, 8.76),
+    (-77.61, 6.80),
+    (-69.14, -52.79),
+    (-66.16, -55.08),
+    (-70.01, -54.88),
+    (-70.55, -53.85),
+    (-59.29, -51.58),
+    (-59.35, -51.54),
+    (-58.65, -51.55),
+    (-58.55, -51.56),
+    (-84.39, 21.44),
+    (-73.90, 19.73),
+    (-79.27, 21.18),
+    (-83.74, 21.80),
+    (-84.32, 21.42),
+    (-66.96, 17.95),
+    (-67.05, 17.89),
+    (-77.88, 17.22),
+    (-78.06, 16.98),
+    (-74.47, 18.08),
+    (-69.88, 18.99),
+    (-71.10, 17.76),
+    (-74.45, 17.86),
+    (-85.28, 73.74),
+    (-85.79, 70.96),
+    (-85.13, 71.94),
+    (-84.74, 72.96),
+    (-80.61, 73.10),
+    (-78.45, 72.20),
+    (-75.44, 72.55),
+    (-73.89, 71.98),
+    (-72.56, 71.04),
+    (-71.49, 70.57),
+    (-69.78, 70.29),
+    (-68.12, 69.71),
+    (-65.91, 69.19),
+    (-66.92, 68.39),
+    (-64.08, 67.68),
+    (-62.50, 66.68),
+    (-63.07, 65.33),
+    (-66.11, 66.08),
+    (-67.48, 65.41),
+    (-64.05, 63.15),
+    (-66.58, 63.26),
+    (-69.04, 62.33),
+    (-72.22, 63.77),
+    (-76.88, 64.17),
+    (-73.25, 65.54),
+    (-70.09, 66.64),
+    (-72.05, 67.44),
+    (-76.32, 68.36),
+    (-78.34, 70.17),
+    (-82.12, 69.71),
+    (-87.64, 70.12),
+    (-89.68, 71.43),
+    (-85.28, 73.74),
+    (-80.90, 76.10),
+    (-84.21, 76.28),
+    (-88.94, 76.38),
+    (-85.47, 77.40),
+    (-85.43, 77.93),
+    (-87.01, 78.54),
+    (-83.17, 78.94),
+    (-84.87, 79.93),
+    (-81.33, 79.82),
+    (-76.27, 80.92),
+    (-82.88, 80.62),
+    (-82.58, 81.16),
+    (-86.51, 81.05),
+    (-89.36, 81.21),
+    (-90.45, 81.38),
+    (-89.28, 81.86),
+    (-87.21, 82.30),
+    (-80.51, 82.05),
+    (-80.16, 82.55),
+    (-77.83, 82.86),
+    (-75.51, 83.05),
+    (-71.18, 82.90),
+    (-65.10, 82.78),
+    (-63.34, 81.80),
+    (-68.26, 81.26),
+    (-69.46, 80.34),
+    (-71.05, 79.82),
+    (-74.40, 79.46),
+    (-75.42, 79.03),
+    (-75.48, 78.92),
+    (-76.01, 78.20),
+    (-80.66, 77.28),
+    (-78.07, 76.98),
+    (-80.90, 76.13),
+    (-92.86, 74.13),
+    (-92.50, 72.70),
+    (-94.89, 73.16),
+    (-92.96, 74.14),
+    (-94.80, 76.95),
+    (-89.68, 76.04),
+    (-88.52, 75.40),
+    (-82.36, 75.67),
+    (-79.39, 74.65),
+    (-86.15, 74.22),
+    (-91.70, 74.94),
+    (-95.60, 76.91),
+    (-94.87, 76.96),
+    (-99.96, 73.74),
+    (-97.89, 72.90),
+    (-98.28, 71.13),
+    (-102.04, 72.92),
+    (-101.34, 73.14),
+    (-99.69, 73.59),
+    (-107.58, 73.25),
+    (-104.59, 71.02),
+    (-101.71, 69.56),
+    (-104.07, 68.62),
+    (-106.61, 69.12),
+    (-114.09, 69.05),
+    (-113.89, 70.12),
+    (-115.88, 70.32),
+    (-116.10, 71.32),
+    (-117.45, 72.48),
+    (-113.53, 72.44),
+    (-109.84, 72.24),
+    (-106.62, 71.71),
+    (-107.43, 73.04),
+    (-120.96, 74.29),
+    (-118.37, 72.53),
+    (-123.06, 71.18),
+    (-123.40, 73.77),
+    (-120.93, 74.27),
+    (-108.83, 76.74),
+    (-106.25, 75.54),
+    (-107.08, 74.78),
+    (-112.99, 74.16),
+    (-112.28, 74.99),
+    (-116.04, 75.33),
+    (-115.27, 76.20),
+    (-110.95, 75.56),
+    (-109.77, 76.31),
+    (-108.82, 76.70),
+    (-115.70, 77.46),
+    (-118.10, 76.30),
+    (-121.13, 76.37),
+    (-116.04, 77.28),
+    (-110.01, 77.86),
+    (-112.36, 77.68),
+    (-109.96, 77.86),
+    (-109.60, 78.48),
+    (-112.20, 78.01),
+    (-109.60, 78.48),
+    (-97.87, 76.61),
+    (-99.21, 75.31),
+    (-100.86, 75.60),
+    (-99.40, 76.26),
+    (-97.79, 76.60),
+    (-94.72, 75.53),
+    (-94.66, 75.52),
+    (-104.10, 79.01),
+    (-99.19, 77.54),
+    (-103.22, 78.08),
+    (-104.30, 78.95),
+    (-93.74, 77.52),
+    (-93.74, 77.52),
+    (-96.88, 78.50),
+    (-96.91, 77.77),
+    (-96.94, 78.48),
+    (-84.69, 65.84),
+    (-81.58, 63.87),
+    (-85.00, 62.96),
+    (-84.63, 65.71),
+    (-81.84, 62.75),
+    (-82.01, 62.63),
+    (-79.88, 62.12),
+    (-79.88, 62.12),
+    (-43.53, 59.89),
+    (-45.29, 60.67),
+    (-47.91, 60.83),
+    (-49.90, 62.41),
+    (-50.71, 64.42),
+    (-51.39, 64.94),
+    (-52.96, 66.09),
+    (-53.62, 67.19),
+    (-53.51, 67.51),
+    (-51.84, 68.65),
+    (-52.19, 70.00),
+    (-51.85, 71.03),
+    (-55.41, 71.41),
+    (-54.63, 72.97),
+    (-56.98, 74.70),
+    (-61.95, 76.09),
+    (-66.38, 75.83),
+    (-71.13, 77.00),
+    (-66.81, 77.60),
+    (-70.78, 77.78),
+    (-64.96, 79.70),
+    (-63.38, 81.16),
+    (-56.89, 82.17),
+    (-48.18, 82.15),
+    (-42.08, 82.74),
+    (-38.02, 83.54),
+    (-23.96, 82.94),
+    (-25.97, 81.97),
+    (-25.99, 80.64),
+    (-13.57, 80.97),
+    (-16.60, 80.16),
+    (-19.82, 78.82),
+    (-18.80, 77.54),
+    (-21.98, 76.46),
+    (-20.69, 75.12),
+    (-21.78, 74.40),
+    (-24.10, 73.69),
+    (-26.54, 73.08),
+    (-24.63, 72.69),
+    (-21.84, 71.69),
+    (-24.62, 71.24),
+    (-27.16, 70.89),
+    (-27.21, 70.00),
+    (-24.10, 69.35),
+    (-28.35, 68.43),
+    (-32.48, 68.56),
+    (-35.26, 66.26),
+    (-37.90, 65.90),
+    (-40.04, 65.00),
+    (-40.49, 64.04),
+    (-42.01, 63.14),
+    (-42.88, 61.15),
+    (-43.09, 60.07),
+    (-43.56, 59.90),
+    (-16.26, 66.41),
+    (-15.32, 64.29),
+    (-20.14, 63.47),
+    (-21.76, 64.21),
+    (-21.33, 64.97),
+    (-23.04, 65.62),
+    (-21.76, 66.26),
+    (-18.77, 66.12),
+    (-16.23, 66.35),
+    (0.56, 51.47),
+    (-1.71, 54.94),
+    (-3.41, 57.52),
+    (-5.42, 58.14),
+    (-5.77, 55.59),
+    (-3.48, 54.82),
+    (-4.68, 52.88),
+    (-2.68, 51.58),
+    (-3.80, 50.08),
+    (1.26, 51.14),
+    (0.65, 51.41),
+    (-7.17, 54.91),
+    (-9.97, 53.47),
+    (-8.52, 51.76),
+    (-5.69, 54.79),
+    (-7.34, 55.25),
+    (-1.33, 60.66),
+    (-1.17, 60.38),
+    (-6.18, 58.44),
+    (-6.09, 58.36),
+    (-6.47, 57.58),
+    (-6.33, 57.54),
+    (-7.30, 57.54),
+    (-7.46, 57.05),
+    (-6.54, 56.94),
+    (-6.00, 55.94),
+    (-5.09, 55.55),
+    (-4.44, 54.38),
+    (-4.30, 54.19),
+    (-8.08, 71.02),
+    (-8.21, 70.86),
+    (16.92, 79.52),
+    (22.26, 78.46),
+    (16.86, 76.41),
+    (16.00, 77.39),
+    (16.03, 77.92),
+    (16.81, 79.50),
+    (14.71, 79.40),
+    (16.05, 79.12),
+    (14.02, 77.80),
+    (13.56, 78.46),
+    (12.63, 79.26),
+    (14.68, 79.40),
+    (22.01, 78.24),
+    (21.86, 78.23),
+    (21.54, 77.75),
+    (23.88, 77.26),
+    (21.53, 77.67),
+    (22.79, 77.79),
+    (23.50, 79.97),
+    (28.24, 79.54),
+    (20.85, 78.94),
+    (19.00, 79.34),
+    (21.05, 79.88),
+    (23.41, 79.96),
+    (46.98, 80.23),
+    (43.13, 79.97),
+    (47.18, 80.22),
+    (50.43, 80.19),
+    (50.55, 79.88),
+    (47.77, 79.86),
+    (50.45, 80.14),
+    (61.79, 80.18),
+    (61.79, 80.18),
+    (65.08, 80.69),
+    (64.27, 80.59),
+    (65.13, 80.68),
+    (-5.13, 35.66),
+    (4.06, 36.63),
+    (10.40, 37.12),
+    (11.36, 33.61),
+    (20.10, 30.10),
+    (23.49, 32.17),
+    (31.65, 30.80),
+    (35.76, 23.74),
+    (39.75, 14.82),
+    (42.93, 11.34),
+    (51.52, 11.45),
+    (49.82, 6.99),
+    (43.13, -0.62),
+    (39.15, -7.58),
+    (40.37, -13.20),
+    (37.74, -18.17),
+    (35.33, -22.71),
+    (32.84, -28.15),
+    (26.50, -34.39),
+    (19.55, -35.51),
+    (17.50, -30.88),
+    (12.24, -18.75),
+    (13.89, -12.81),
+    (12.05, -5.55),
+    (9.67, 0.14),
+    (7.19, 3.79),
+    (1.74, 5.39),
+    (-4.77, 4.59),
+    (-12.00, 6.75),
+    (-15.54, 10.98),
+    (-16.33, 15.50),
+    (-16.10, 22.29),
+    (-12.90, 27.12),
+    (-9.52, 31.09),
+    (-5.41, 35.58),
+    (33.71, 0.00),
+    (33.48, -3.42),
+    (33.34, -0.20),
+    (33.71, 0.00),
+    (49.30, -12.50),
+    (49.28, -18.79),
+    (43.95, -25.50),
+    (44.37, -20.08),
+    (46.34, -16.31),
+    (47.91, -14.08),
+    (49.30, -12.50),
+    (178.88, 69.10),
+    (181.20, 68.42),
+    (183.52, 67.78),
+    (188.87, 66.38),
+    (186.54, 64.74),
+    (182.87, 65.63),
+    (180.13, 65.14),
+    (179.48, 64.88),
+    (178.20, 64.29),
+    (177.46, 62.62),
+    (170.42, 60.17),
+    (164.48, 59.89),
+    (162.92, 57.34),
+    (161.82, 54.88),
+    (156.42, 51.09),
+    (156.40, 57.76),
+    (163.79, 61.73),
+    (159.90, 60.73),
+    (156.81, 61.68),
+    (153.83, 59.10),
+    (148.57, 59.46),
+    (140.77, 58.39),
+    (137.10, 54.07),
+    (140.72, 52.43),
+    (138.77, 47.30),
+    (129.92, 42.04),
+    (128.33, 38.46),
+    (126.15, 35.18),
+    (125.12, 39.08),
+    (121.62, 40.15),
+    (117.58, 38.21),
+    (121.77, 36.90),
+    (120.73, 32.65),
+    (121.28, 30.25),
+    (118.83, 24.93),
+    (112.69, 21.81),
+    (108.53, 21.73),
+    (107.55, 16.34),
+    (107.32, 10.45),
+    (104.39, 10.37),
+    (100.01, 13.52),
+    (100.26, 8.30),
+    (103.22, 1.56),
+    (98.21, 9.17),
+    (97.66, 15.36),
+    (94.21, 17.79),
+    (90.05, 21.74),
+    (90.06, 21.03),
+    (82.06, 15.95),
+    (80.05, 11.72),
+    (76.41, 8.60),
+    (72.79, 17.43),
+    (72.02, 20.00),
+    (68.98, 21.99),
+    (64.62, 24.41),
+    (57.83, 24.77),
+    (53.11, 26.20),
+    (49.67, 29.41),
+    (50.96, 25.15),
+    (54.33, 23.44),
+    (59.03, 22.57),
+    (57.87, 18.86),
+    (52.95, 15.74),
+    (47.26, 12.96),
+    (42.75, 14.68),
+    (39.93, 19.61),
+    (36.92, 25.78),
+    (33.30, 28.46),
+    (32.60, 30.63),
+    (32.18, 30.58),
+    (36.08, 35.03),
+    (32.53, 36.17),
+    (27.77, 36.94),
+    (26.51, 39.18),
+    (31.54, 40.82),
+    (38.53, 40.48),
+    (40.35, 43.17),
+    (39.88, 46.45),
+    (35.18, 44.99),
+    (33.50, 44.96),
+    (30.24, 45.14),
+    (28.70, 41.48),
+    (26.55, 39.84),
+    (23.62, 39.67),
+    (23.80, 37.34),
+    (21.90, 36.92),
+    (18.79, 42.02),
+    (14.52, 44.31),
+    (14.58, 42.25),
+    (18.32, 39.57),
+    (16.05, 39.35),
+    (11.52, 42.36),
+    (6.87, 43.08),
+    (2.80, 41.09),
+    (-1.11, 37.14),
+    (-6.24, 36.70),
+    (-8.67, 39.57),
+    (-6.51, 43.13),
+    (-0.84, 45.55),
+    (-3.93, 48.40),
+    (0.48, 49.09),
+    (4.20, 51.29),
+    (6.44, 52.92),
+    (8.42, 55.94),
+    (11.72, 55.49),
+    (11.73, 53.66),
+    (16.78, 54.14),
+    (21.40, 56.32),
+    (24.67, 57.20),
+    (28.94, 59.18),
+    (24.16, 59.52),
+    (22.07, 62.66),
+    (23.76, 65.35),
+    (18.70, 62.54),
+    (19.11, 59.67),
+    (18.40, 58.54),
+    (15.34, 55.73),
+    (11.74, 58.08),
+    (8.37, 57.68),
+    (5.80, 59.20),
+    (7.38, 60.86),
+    (7.51, 61.86),
+    (9.62, 62.99),
+    (13.37, 65.46),
+    (15.46, 67.12),
+    (18.54, 68.62),
+    (22.32, 69.64),
+    (24.77, 70.17),
+    (25.93, 69.79),
+    (28.56, 70.46),
+    (29.75, 69.76),
+    (33.83, 69.11),
+    (41.90, 66.85),
+    (35.14, 66.25),
+    (33.30, 66.07),
+    (35.46, 64.15),
+    (37.68, 64.03),
+    (41.71, 64.09),
+    (44.80, 65.58),
+    (44.87, 68.16),
+    (45.92, 66.83),
+    (51.79, 67.85),
+    (53.70, 67.89),
+    (59.68, 68.09),
+    (65.07, 69.08),
+    (68.56, 69.19),
+    (68.38, 70.97),
+    (73.03, 71.62),
+    (73.80, 68.29),
+    (69.42, 66.45),
+    (73.43, 66.36),
+    (77.51, 68.36),
+    (80.74, 66.74),
+    (75.27, 68.67),
+    (75.11, 71.80),
+    (78.62, 70.56),
+    (78.43, 71.90),
+    (82.72, 71.23),
+    (84.25, 70.03),
+    (81.40, 72.76),
+    (86.50, 74.01),
+    (87.68, 74.78),
+    (90.25, 75.23),
+    (89.68, 75.57),
+    (95.12, 75.95),
+    (99.69, 76.09),
+    (104.10, 77.52),
+    (106.34, 76.40),
+    (112.99, 75.60),
+    (107.88, 73.72),
+    (110.43, 73.71),
+    (113.34, 73.37),
+    (123.10, 73.28),
+    (128.94, 73.02),
+    (126.10, 72.24),
+    (130.53, 70.86),
+    (135.49, 71.51),
+    (139.60, 72.23),
+    (146.04, 72.39),
+    (146.92, 72.21),
+    (150.77, 71.28),
+    (159.92, 70.14),
+    (167.68, 69.63),
+    (170.20, 69.99),
+    (178.88, 69.10),
+    (68.33, 76.71),
+    (66.03, 75.62),
+    (59.10, 74.11),
+    (54.92, 73.03),
+    (56.67, 74.10),
+    (58.56, 75.09),
+    (63.86, 75.87),
+    (68.19, 76.70),
+    (53.04, 72.57),
+    (58.29, 70.39),
+    (55.03, 70.78),
+    (53.44, 72.26),
+    (53.63, 72.61),
+    (52.22, 46.50),
+    (51.73, 44.73),
+    (52.56, 41.80),
+    (53.43, 40.40),
+    (54.22, 37.86),
+    (49.04, 38.45),
+    (48.17, 42.76),
+    (49.33, 45.64),
+    (52.22, 46.50),
+    (62.32, 46.32),
+    (60.32, 43.06),
+    (59.57, 45.58),
+    (61.94, 46.33),
+    (79.55, 46.12),
+    (74.30, 44.44),
+    (78.62, 45.79),
+    (79.66, 46.07),
+    (76.81, 41.96),
+    (76.73, 41.86),
+    (35.15, 35.15),
+    (34.61, 34.84),
+    (35.18, 35.17),
+    (23.84, 35.33),
+    (24.30, 34.91),
+    (24.09, 35.39),
+    (15.54, 37.89),
+    (13.47, 37.89),
+    (15.54, 37.89),
+    (9.56, 40.95),
+    (8.46, 39.99),
+    (9.12, 40.69),
+    (9.72, 42.60),
+    (9.54, 42.35),
+    (80.60, 8.95),
+    (79.73, 5.96),
+    (80.10, 8.30),
+    (11.04, 57.44),
+    (10.67, 57.25),
+    (-77.92, 24.67),
+    (-77.98, 24.22),
+    (-77.61, 23.62),
+    (-77.18, 23.64),
+    (-75.55, 24.13),
+    (-75.41, 24.31),
+    (-91.40, -0.17),
+    (-91.52, -0.26),
+    (-60.25, 46.68),
+    (-60.71, 46.33),
+    (-63.89, 49.47),
+    (-63.45, 49.43),
+    (142.53, -10.60),
+    (145.62, -16.34),
+    (149.79, -22.09),
+    (153.21, -26.82),
+    (150.52, -35.19),
+    (145.60, -38.53),
+    (140.13, -37.69),
+    (137.34, -34.77),
+    (135.76, -34.56),
+    (131.50, -31.34),
+    (121.72, -33.65),
+    (115.62, -33.25),
+    (114.09, -26.01),
+    (114.88, -21.27),
+    (122.34, -18.13),
+    (125.32, -14.53),
+    (128.39, -14.90),
+    (132.35, -11.42),
+    (136.16, -12.43),
+    (138.07, -16.45),
+    (142.25, -10.78),
+    (144.72, -40.68),
+    (148.32, -42.14),
+    (145.57, -42.77),
+    (146.47, -41.19),
+    (172.86, -34.23),
+    (176.10, -37.52),
+    (177.06, -39.49),
+    (174.77, -38.03),
+    (172.83, -34.27),
+    (172.36, -40.53),
+    (172.92, -43.81),
+    (168.41, -46.13),
+    (170.26, -43.21),
+    (173.69, -40.94),
+    (150.74, -10.18),
+    (143.04, -8.26),
+    (138.48, -6.97),
+    (131.95, -2.94),
+    (130.91, -1.35),
+    (134.38, -2.64),
+    (141.24, -2.62),
+    (148.19, -8.15),
+    (150.75, -10.27),
+    (117.24, 7.01),
+    (117.90, 0.76),
+    (113.89, -3.50),
+    (109.44, -0.82),
+    (113.13, 3.38),
+    (117.24, 7.01),
+    (95.31, 5.75),
+    (102.32, 1.40),
+    (106.03, -2.98),
+    (101.46, -2.81),
+    (95.20, 5.73),
+    (140.91, 41.53),
+    (140.79, 35.75),
+    (136.82, 34.56),
+    (133.56, 34.72),
+    (132.49, 35.41),
+    (136.73, 37.20),
+    (139.82, 40.00),
+    (140.68, 41.43),
+    (133.71, 34.30),
+    (131.41, 31.58),
+    (129.38, 33.10),
+    (133.90, 34.37),
+    (141.89, 45.50),
+    (144.12, 42.92),
+    (140.30, 41.64),
+    (141.53, 45.30),
+    (141.89, 45.53),
+    (142.57, 54.36),
+    (143.64, 49.19),
+    (141.99, 45.88),
+    (141.92, 50.85),
+    (142.60, 54.34),
+    (121.92, 25.48),
+    (120.53, 24.70),
+    (121.70, 25.51),
+    (110.81, 20.07),
+    (109.20, 19.66),
+    (110.81, 20.07),
+    (106.51, -6.16),
+    (114.15, -7.72),
+    (108.71, -7.89),
+    (106.51, -6.16),
+    (164.27, -20.01),
+    (164.16, -20.27),
+    (178.61, -17.04),
+    (178.61, -17.04),
+    (179.45, -16.43),
+    (179.35, -16.43),
+    (-172.55, -13.39),
+    (-172.61, -13.78),
+    (122.26, 18.67),
+    (123.05, 13.86),
+    (120.73, 13.80),
+    (120.43, 16.43),
+    (121.72, 18.40),
+    (125.34, 9.79),
+    #[allow(clippy::approx_constant)]
+    (125.56, 6.28),
+    (122.38, 7.00),
+    (125.10, 9.38),
+    (119.64, 11.35),
+    (118.81, 10.16),
+    (119.59, 10.86),
+    (119.64, 11.35),
+    (-179.87, 65.14),
+    (-177.13, 65.63),
+    (-173.46, 64.74),
+    (-171.13, 66.38),
+    (-176.48, 67.78),
+    (-178.80, 68.42),
+    (101.96, 79.08),
+    (101.31, 77.86),
+    (101.22, 79.04),
+    (94.29, 79.29),
+    (95.31, 78.68),
+    (100.02, 79.43),
+    (97.26, 79.62),
+    (95.44, 79.65),
+    (95.46, 80.62),
+    (92.39, 79.66),
+    (95.07, 80.54),
+    (138.54, 76.05),
+    (144.93, 75.45),
+    (140.30, 74.99),
+    (137.27, 75.44),
+    (138.29, 75.98),
+    (146.08, 75.29),
+    (147.75, 74.73),
+    (145.85, 75.06),
+    (141.44, 73.88),
+    (141.48, 73.84),
+    (0.01, -71.68),
+    (6.57, -70.57),
+    (15.04, -70.44),
+    (25.10, -70.75),
+    (33.37, -69.10),
+    (38.46, -69.77),
+    (42.85, -68.16),
+    (46.59, -67.23),
+    (49.35, -66.96),
+    (52.90, -65.97),
+    (58.46, -67.20),
+    (63.60, -67.58),
+    (70.63, -68.41),
+    (69.24, -70.36),
+    (76.20, -69.44),
+    (88.08, -66.64),
+    (94.98, -66.52),
+    (101.53, -66.09),
+    (111.31, -65.91),
+    (118.64, -66.87),
+    (126.24, -66.24),
+    (133.09, -66.18),
+    (139.85, -66.72),
+    (146.86, -67.96),
+    (153.65, -68.82),
+    (159.94, -69.57),
+    (164.10, -70.67),
+    (170.19, -71.94),
+    (165.68, -74.64),
+    (163.82, -77.60),
+    (162.10, -78.95),
+    (166.72, -82.84),
+    (175.58, -83.86),
+    (-178.56, -84.37),
+    (-147.96, -85.40),
+    (-152.96, -81.12),
+    (-153.95, -79.50),
+    (-151.24, -77.48),
+    (-146.74, -76.44),
+    (-137.68, -75.16),
+    (-131.63, -74.63),
+    (-123.05, -74.41),
+    (-114.76, -73.97),
+    (-111.91, -75.41),
+    (-105.05, -74.77),
+    (-100.90, -74.21),
+    (-101.04, -73.18),
+    (-100.28, -73.06),
+    (-93.06, -73.33),
+    (-85.40, -73.18),
+    (-79.82, -73.04),
+    (-78.21, -72.52),
+    (-71.90, -73.41),
+    (-67.51, -71.10),
+    (-67.57, -68.92),
+    (-66.65, -66.83),
+    (-64.30, -65.28),
+    (-59.14, -63.74),
+    (-59.58, -64.37),
+    (-62.50, -65.94),
+    (-62.48, -66.66),
+    (-65.64, -68.02),
+    (-63.85, -69.07),
+    (-61.69, -70.87),
+    (-60.89, -72.71),
+    (-61.07, -74.30),
+    (-63.33, -75.88),
+    (-76.05, -77.06),
+    (-83.04, -77.12),
+    (-74.30, -80.83),
+    (-56.40, -82.14),
+    (-42.46, -81.65),
+    (-31.60, -80.17),
+    (-34.01, -79.20),
+    (-32.48, -77.28),
+    (-26.28, -76.18),
+    (-17.18, -73.45),
+    (-11.20, -72.01),
+    (-8.67, -71.98),
+    (-5.45, -71.45),
+    (-0.82, -71.74),
+    (0.07, -71.68),
+    (164.65, -77.89),
+    (170.95, -77.37),
+    (179.67, -78.25),
+    (-178.74, -78.24),
+    (-165.76, -78.47),
+    (-158.42, -77.73),
+    (-58.98, -64.63),
+    (-60.99, -68.62),
+    (-61.02, -71.70),
+    (-62.01, -74.94),
+    (-52.00, -77.07),
+    (-42.23, -77.80),
+    (-36.22, -78.03),
+    (-35.03, -77.81),
+    (-26.13, -75.54),
+    (-19.35, -73.04),
+    (-12.16, -71.86),
+    (-6.15, -70.65),
+    (-0.57, -69.14),
+    (4.93, -70.25),
+    (10.91, -69.99),
+    (16.52, -69.87),
+    (25.41, -70.22),
+    (32.13, -69.29),
+    (33.62, -69.58),
+    (70.56, -68.53),
+    (73.91, -69.51),
+    (81.42, -67.87),
+    (84.67, -66.41),
+    (89.07, -66.73),
+    (-135.79, -74.67),
+    (-124.34, -73.22),
+    (-116.65, -74.08),
+    (-109.93, -74.64),
+    (-105.36, -74.56),
+    (-105.83, -74.77),
+    (-69.30, -70.06),
+    (-71.33, -72.68),
+    (-71.42, -71.85),
+    (-75.10, -71.46),
+    (-71.79, -70.55),
+    (-70.34, -69.26),
+    (-69.34, -70.13),
+    (-49.20, -77.83),
+    (-44.59, -78.79),
+    (-44.14, -80.13),
+    (-59.04, -79.95),
+    (-49.28, -77.84),
+    (-48.24, -77.81),
+    (-58.13, -80.12),
+    (-63.25, -80.20),
+    (-58.32, -80.12),
+    (-163.64, -78.74),
+    (-161.20, -79.93),
+    (-163.62, -78.74),
+    (66.82, 66.82),
+    (66.82, 66.82),
+];
diff --git a/src/ratatui/widgets/chart.rs b/src/ratatui/widgets/chart.rs
new file mode 100644
index 00000000..a57a392b
--- /dev/null
+++ b/src/ratatui/widgets/chart.rs
@@ -0,0 +1,660 @@
+use std::{borrow::Cow, cmp::max};
+
+use unicode_width::UnicodeWidthStr;
+
+use crate::ratatui::layout::Alignment;
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::{Constraint, Rect},
+    style::{Color, Style},
+    symbols,
+    text::{Span, Spans},
+    widgets::{
+        canvas::{Canvas, Line, Points},
+        Block, Borders, Widget,
+    },
+};
+
+/// An X or Y axis for the chart widget
+#[derive(Debug, Clone)]
+pub struct Axis<'a> {
+    /// Title displayed next to axis end
+    title: Option<Spans<'a>>,
+    /// Bounds for the axis (all data points outside these limits will not be represented)
+    bounds: [f64; 2],
+    /// A list of labels to put to the left or below the axis
+    labels: Option<Vec<Span<'a>>>,
+    /// The style used to draw the axis itself
+    style: Style,
+    /// The alignment of the labels of the Axis
+    labels_alignment: Alignment,
+}
+
+impl<'a> Default for Axis<'a> {
+    fn default() -> Axis<'a> {
+        Axis {
+            title: None,
+            bounds: [0.0, 0.0],
+            labels: None,
+            style: Default::default(),
+            labels_alignment: Alignment::Left,
+        }
+    }
+}
+
+impl<'a> Axis<'a> {
+    pub fn title<T>(mut self, title: T) -> Axis<'a>
+    where
+        T: Into<Spans<'a>>,
+    {
+        self.title = Some(title.into());
+        self
+    }
+
+    #[deprecated(
+        since = "0.10.0",
+        note = "You should use styling capabilities of `text::Spans` given as argument of the `title` method to apply styling to the title."
+    )]
+    pub fn title_style(mut self, style: Style) -> Axis<'a> {
+        if let Some(t) = self.title {
+            let title = String::from(t);
+            self.title = Some(Spans::from(Span::styled(title, style)));
+        }
+        self
+    }
+
+    pub fn bounds(mut self, bounds: [f64; 2]) -> Axis<'a> {
+        self.bounds = bounds;
+        self
+    }
+
+    pub fn labels(mut self, labels: Vec<Span<'a>>) -> Axis<'a> {
+        self.labels = Some(labels);
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Axis<'a> {
+        self.style = style;
+        self
+    }
+
+    /// Defines the alignment of the labels of the axis.
+    /// The alignment behaves differently based on the axis:
+    /// - Y-Axis: The labels are aligned within the area on the left of the axis
+    /// - X-Axis: The first X-axis label is aligned relative to the Y-axis
+    pub fn labels_alignment(mut self, alignment: Alignment) -> Axis<'a> {
+        self.labels_alignment = alignment;
+        self
+    }
+}
+
+/// Used to determine which style of graphing to use
+#[derive(Debug, Clone, Copy)]
+pub enum GraphType {
+    /// Draw each point
+    Scatter,
+    /// Draw each point and lines between each point using the same marker
+    Line,
+}
+
+/// A group of data points
+#[derive(Debug, Clone)]
+pub struct Dataset<'a> {
+    /// Name of the dataset (used in the legend if shown)
+    name: Cow<'a, str>,
+    /// A reference to the actual data
+    data: &'a [(f64, f64)],
+    /// Symbol used for each points of this dataset
+    marker: symbols::Marker,
+    /// Determines graph type used for drawing points
+    graph_type: GraphType,
+    /// Style used to plot this dataset
+    style: Style,
+}
+
+impl<'a> Default for Dataset<'a> {
+    fn default() -> Dataset<'a> {
+        Dataset {
+            name: Cow::from(""),
+            data: &[],
+            marker: symbols::Marker::Dot,
+            graph_type: GraphType::Scatter,
+            style: Style::default(),
+        }
+    }
+}
+
+impl<'a> Dataset<'a> {
+    pub fn name<S>(mut self, name: S) -> Dataset<'a>
+    where
+        S: Into<Cow<'a, str>>,
+    {
+        self.name = name.into();
+        self
+    }
+
+    pub fn data(mut self, data: &'a [(f64, f64)]) -> Dataset<'a> {
+        self.data = data;
+        self
+    }
+
+    pub fn marker(mut self, marker: symbols::Marker) -> Dataset<'a> {
+        self.marker = marker;
+        self
+    }
+
+    pub fn graph_type(mut self, graph_type: GraphType) -> Dataset<'a> {
+        self.graph_type = graph_type;
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Dataset<'a> {
+        self.style = style;
+        self
+    }
+}
+
+/// A container that holds all the infos about where to display each elements of the chart (axis,
+/// labels, legend, ...).
+#[derive(Debug, Clone, PartialEq, Default)]
+struct ChartLayout {
+    /// Location of the title of the x axis
+    title_x: Option<(u16, u16)>,
+    /// Location of the title of the y axis
+    title_y: Option<(u16, u16)>,
+    /// Location of the first label of the x axis
+    label_x: Option<u16>,
+    /// Location of the first label of the y axis
+    label_y: Option<u16>,
+    /// Y coordinate of the horizontal axis
+    axis_x: Option<u16>,
+    /// X coordinate of the vertical axis
+    axis_y: Option<u16>,
+    /// Area of the legend
+    legend_area: Option<Rect>,
+    /// Area of the graph
+    graph_area: Rect,
+}
+
+/// A widget to plot one or more dataset in a cartesian coordinate system
+///
+/// # Examples
+///
+/// ```
+/// # use ratatui::symbols;
+/// # use ratatui::widgets::{Block, Borders, Chart, Axis, Dataset, GraphType};
+/// # use ratatui::style::{Style, Color};
+/// # use ratatui::text::Span;
+/// let datasets = vec![
+///     Dataset::default()
+///         .name("data1")
+///         .marker(symbols::Marker::Dot)
+///         .graph_type(GraphType::Scatter)
+///         .style(Style::default().fg(Color::Cyan))
+///         .data(&[(0.0, 5.0), (1.0, 6.0), (1.5, 6.434)]),
+///     Dataset::default()
+///         .name("data2")
+///         .marker(symbols::Marker::Braille)
+///         .graph_type(GraphType::Line)
+///         .style(Style::default().fg(Color::Magenta))
+///         .data(&[(4.0, 5.0), (5.0, 8.0), (7.66, 13.5)]),
+/// ];
+/// Chart::new(datasets)
+///     .block(Block::default().title("Chart"))
+///     .x_axis(Axis::default()
+///         .title(Span::styled("X Axis", Style::default().fg(Color::Red)))
+///         .style(Style::default().fg(Color::White))
+///         .bounds([0.0, 10.0])
+///         .labels(["0.0", "5.0", "10.0"].iter().cloned().map(Span::from).collect()))
+///     .y_axis(Axis::default()
+///         .title(Span::styled("Y Axis", Style::default().fg(Color::Red)))
+///         .style(Style::default().fg(Color::White))
+///         .bounds([0.0, 10.0])
+///         .labels(["0.0", "5.0", "10.0"].iter().cloned().map(Span::from).collect()));
+/// ```
+#[derive(Debug, Clone)]
+pub struct Chart<'a> {
+    /// A block to display around the widget eventually
+    block: Option<Block<'a>>,
+    /// The horizontal axis
+    x_axis: Axis<'a>,
+    /// The vertical axis
+    y_axis: Axis<'a>,
+    /// A reference to the datasets
+    datasets: Vec<Dataset<'a>>,
+    /// The widget base style
+    style: Style,
+    /// Constraints used to determine whether the legend should be shown or not
+    hidden_legend_constraints: (Constraint, Constraint),
+}
+
+impl<'a> Chart<'a> {
+    pub fn new(datasets: Vec<Dataset<'a>>) -> Chart<'a> {
+        Chart {
+            block: None,
+            x_axis: Axis::default(),
+            y_axis: Axis::default(),
+            style: Default::default(),
+            datasets,
+            hidden_legend_constraints: (Constraint::Ratio(1, 4), Constraint::Ratio(1, 4)),
+        }
+    }
+
+    pub fn block(mut self, block: Block<'a>) -> Chart<'a> {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Chart<'a> {
+        self.style = style;
+        self
+    }
+
+    pub fn x_axis(mut self, axis: Axis<'a>) -> Chart<'a> {
+        self.x_axis = axis;
+        self
+    }
+
+    pub fn y_axis(mut self, axis: Axis<'a>) -> Chart<'a> {
+        self.y_axis = axis;
+        self
+    }
+
+    /// Set the constraints used to determine whether the legend should be shown or not.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use ratatui::widgets::Chart;
+    /// # use ratatui::layout::Constraint;
+    /// let constraints = (
+    ///     Constraint::Ratio(1, 3),
+    ///     Constraint::Ratio(1, 4)
+    /// );
+    /// // Hide the legend when either its width is greater than 33% of the total widget width
+    /// // or if its height is greater than 25% of the total widget height.
+    /// let _chart: Chart = Chart::new(vec![])
+    ///     .hidden_legend_constraints(constraints);
+    /// ```
+    pub fn hidden_legend_constraints(mut self, constraints: (Constraint, Constraint)) -> Chart<'a> {
+        self.hidden_legend_constraints = constraints;
+        self
+    }
+
+    /// Compute the internal layout of the chart given the area. If the area is too small some
+    /// elements may be automatically hidden
+    fn layout(&self, area: Rect) -> ChartLayout {
+        let mut layout = ChartLayout::default();
+        if area.height == 0 || area.width == 0 {
+            return layout;
+        }
+        let mut x = area.left();
+        let mut y = area.bottom() - 1;
+
+        if self.x_axis.labels.is_some() && y > area.top() {
+            layout.label_x = Some(y);
+            y -= 1;
+        }
+
+        layout.label_y = self.y_axis.labels.as_ref().and(Some(x));
+        x += self.max_width_of_labels_left_of_y_axis(area, self.y_axis.labels.is_some());
+
+        if self.x_axis.labels.is_some() && y > area.top() {
+            layout.axis_x = Some(y);
+            y -= 1;
+        }
+
+        if self.y_axis.labels.is_some() && x + 1 < area.right() {
+            layout.axis_y = Some(x);
+            x += 1;
+        }
+
+        if x < area.right() && y > 1 {
+            layout.graph_area = Rect::new(x, area.top(), area.right() - x, y - area.top() + 1);
+        }
+
+        if let Some(ref title) = self.x_axis.title {
+            let w = title.width() as u16;
+            if w < layout.graph_area.width && layout.graph_area.height > 2 {
+                layout.title_x = Some((x + layout.graph_area.width - w, y));
+            }
+        }
+
+        if let Some(ref title) = self.y_axis.title {
+            let w = title.width() as u16;
+            if w + 1 < layout.graph_area.width && layout.graph_area.height > 2 {
+                layout.title_y = Some((x, area.top()));
+            }
+        }
+
+        if let Some(inner_width) = self.datasets.iter().map(|d| d.name.width() as u16).max() {
+            let legend_width = inner_width + 2;
+            let legend_height = self.datasets.len() as u16 + 2;
+            let max_legend_width = self
+                .hidden_legend_constraints
+                .0
+                .apply(layout.graph_area.width);
+            let max_legend_height = self
+                .hidden_legend_constraints
+                .1
+                .apply(layout.graph_area.height);
+            if inner_width > 0
+                && legend_width < max_legend_width
+                && legend_height < max_legend_height
+            {
+                layout.legend_area = Some(Rect::new(
+                    layout.graph_area.right() - legend_width,
+                    layout.graph_area.top(),
+                    legend_width,
+                    legend_height,
+                ));
+            }
+        }
+        layout
+    }
+
+    fn max_width_of_labels_left_of_y_axis(&self, area: Rect, has_y_axis: bool) -> u16 {
+        let mut max_width = self
+            .y_axis
+            .labels
+            .as_ref()
+            .map(|l| l.iter().map(Span::width).max().unwrap_or_default() as u16)
+            .unwrap_or_default();
+
+        if let Some(first_x_label) = self.x_axis.labels.as_ref().and_then(|labels| labels.get(0)) {
+            let first_label_width = first_x_label.content.width() as u16;
+            let width_left_of_y_axis = match self.x_axis.labels_alignment {
+                Alignment::Left => {
+                    // The last character of the label should be below the Y-Axis when it exists, not on its left
+                    let y_axis_offset = if has_y_axis { 1 } else { 0 };
+                    first_label_width.saturating_sub(y_axis_offset)
+                }
+                Alignment::Center => first_label_width / 2,
+                Alignment::Right => 0,
+            };
+            max_width = max(max_width, width_left_of_y_axis);
+        }
+        // labels of y axis and first label of x axis can take at most 1/3rd of the total width
+        max_width.min(area.width / 3)
+    }
+
+    fn render_x_labels(
+        &mut self,
+        buf: &mut Buffer,
+        layout: &ChartLayout,
+        chart_area: Rect,
+        graph_area: Rect,
+    ) {
+        let y = match layout.label_x {
+            Some(y) => y,
+            None => return,
+        };
+        let labels = self.x_axis.labels.as_ref().unwrap();
+        let labels_len = labels.len() as u16;
+        if labels_len < 2 {
+            return;
+        }
+
+        let width_between_ticks = graph_area.width / labels_len;
+
+        let label_area = self.first_x_label_area(
+            y,
+            labels.first().unwrap().width() as u16,
+            width_between_ticks,
+            chart_area,
+            graph_area,
+        );
+
+        let label_alignment = match self.x_axis.labels_alignment {
+            Alignment::Left => Alignment::Right,
+            Alignment::Center => Alignment::Center,
+            Alignment::Right => Alignment::Left,
+        };
+
+        Self::render_label(buf, labels.first().unwrap(), label_area, label_alignment);
+
+        for (i, label) in labels[1..labels.len() - 1].iter().enumerate() {
+            // We add 1 to x (and width-1 below) to leave at least one space before each intermediate labels
+            let x = graph_area.left() + (i + 1) as u16 * width_between_ticks + 1;
+            let label_area = Rect::new(x, y, width_between_ticks.saturating_sub(1), 1);
+
+            Self::render_label(buf, label, label_area, Alignment::Center);
+        }
+
+        let x = graph_area.right() - width_between_ticks;
+        let label_area = Rect::new(x, y, width_between_ticks, 1);
+        // The last label should be aligned Right to be at the edge of the graph area
+        Self::render_label(buf, labels.last().unwrap(), label_area, Alignment::Right);
+    }
+
+    fn first_x_label_area(
+        &self,
+        y: u16,
+        label_width: u16,
+        max_width_after_y_axis: u16,
+        chart_area: Rect,
+        graph_area: Rect,
+    ) -> Rect {
+        let (min_x, max_x) = match self.x_axis.labels_alignment {
+            Alignment::Left => (chart_area.left(), graph_area.left()),
+            Alignment::Center => (
+                chart_area.left(),
+                graph_area.left() + max_width_after_y_axis.min(label_width),
+            ),
+            Alignment::Right => (
+                graph_area.left().saturating_sub(1),
+                graph_area.left() + max_width_after_y_axis,
+            ),
+        };
+
+        Rect::new(min_x, y, max_x - min_x, 1)
+    }
+
+    fn render_label(buf: &mut Buffer, label: &Span, label_area: Rect, alignment: Alignment) {
+        let label_width = label.width() as u16;
+        let bounded_label_width = label_area.width.min(label_width);
+
+        let x = match alignment {
+            Alignment::Left => label_area.left(),
+            Alignment::Center => label_area.left() + label_area.width / 2 - bounded_label_width / 2,
+            Alignment::Right => label_area.right() - bounded_label_width,
+        };
+
+        buf.set_span(x, label_area.top(), label, bounded_label_width);
+    }
+
+    fn render_y_labels(
+        &mut self,
+        buf: &mut Buffer,
+        layout: &ChartLayout,
+        chart_area: Rect,
+        graph_area: Rect,
+    ) {
+        let x = match layout.label_y {
+            Some(x) => x,
+            None => return,
+        };
+        let labels = self.y_axis.labels.as_ref().unwrap();
+        let labels_len = labels.len() as u16;
+        for (i, label) in labels.iter().enumerate() {
+            let dy = i as u16 * (graph_area.height - 1) / (labels_len - 1);
+            if dy < graph_area.bottom() {
+                let label_area = Rect::new(
+                    x,
+                    graph_area.bottom().saturating_sub(1) - dy,
+                    (graph_area.left() - chart_area.left()).saturating_sub(1),
+                    1,
+                );
+                Self::render_label(buf, label, label_area, self.y_axis.labels_alignment);
+            }
+        }
+    }
+}
+
+impl<'a> Widget for Chart<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        if area.area() == 0 {
+            return;
+        }
+        buf.set_style(area, self.style);
+        // Sample the style of the entire widget. This sample will be used to reset the style of
+        // the cells that are part of the components put on top of the grah area (i.e legend and
+        // axis names).
+        let original_style = buf.get(area.left(), area.top()).style();
+
+        let chart_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        let layout = self.layout(chart_area);
+        let graph_area = layout.graph_area;
+        if graph_area.width < 1 || graph_area.height < 1 {
+            return;
+        }
+
+        self.render_x_labels(buf, &layout, chart_area, graph_area);
+        self.render_y_labels(buf, &layout, chart_area, graph_area);
+
+        if let Some(y) = layout.axis_x {
+            for x in graph_area.left()..graph_area.right() {
+                buf.get_mut(x, y)
+                    .set_symbol(symbols::line::HORIZONTAL)
+                    .set_style(self.x_axis.style);
+            }
+        }
+
+        if let Some(x) = layout.axis_y {
+            for y in graph_area.top()..graph_area.bottom() {
+                buf.get_mut(x, y)
+                    .set_symbol(symbols::line::VERTICAL)
+                    .set_style(self.y_axis.style);
+            }
+        }
+
+        if let Some(y) = layout.axis_x {
+            if let Some(x) = layout.axis_y {
+                buf.get_mut(x, y)
+                    .set_symbol(symbols::line::BOTTOM_LEFT)
+                    .set_style(self.x_axis.style);
+            }
+        }
+
+        for dataset in &self.datasets {
+            Canvas::default()
+                .background_color(self.style.bg.unwrap_or(Color::Reset))
+                .x_bounds(self.x_axis.bounds)
+                .y_bounds(self.y_axis.bounds)
+                .marker(dataset.marker)
+                .paint(|ctx| {
+                    ctx.draw(&Points {
+                        coords: dataset.data,
+                        color: dataset.style.fg.unwrap_or(Color::Reset),
+                    });
+                    if let GraphType::Line = dataset.graph_type {
+                        for data in dataset.data.windows(2) {
+                            ctx.draw(&Line {
+                                x1: data[0].0,
+                                y1: data[0].1,
+                                x2: data[1].0,
+                                y2: data[1].1,
+                                color: dataset.style.fg.unwrap_or(Color::Reset),
+                            })
+                        }
+                    }
+                })
+                .render(graph_area, buf);
+        }
+
+        if let Some(legend_area) = layout.legend_area {
+            buf.set_style(legend_area, original_style);
+            Block::default()
+                .borders(Borders::ALL)
+                .render(legend_area, buf);
+            for (i, dataset) in self.datasets.iter().enumerate() {
+                buf.set_string(
+                    legend_area.x + 1,
+                    legend_area.y + 1 + i as u16,
+                    &dataset.name,
+                    dataset.style,
+                );
+            }
+        }
+
+        if let Some((x, y)) = layout.title_x {
+            let title = self.x_axis.title.unwrap();
+            let width = graph_area.right().saturating_sub(x);
+            buf.set_style(
+                Rect {
+                    x,
+                    y,
+                    width,
+                    height: 1,
+                },
+                original_style,
+            );
+            buf.set_spans(x, y, &title, width);
+        }
+
+        if let Some((x, y)) = layout.title_y {
+            let title = self.y_axis.title.unwrap();
+            let width = graph_area.right().saturating_sub(x);
+            buf.set_style(
+                Rect {
+                    x,
+                    y,
+                    width,
+                    height: 1,
+                },
+                original_style,
+            );
+            buf.set_spans(x, y, &title, width);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct LegendTestCase {
+        chart_area: Rect,
+        hidden_legend_constraints: (Constraint, Constraint),
+        legend_area: Option<Rect>,
+    }
+
+    #[test]
+    fn it_should_hide_the_legend() {
+        let data = [(0.0, 5.0), (1.0, 6.0), (3.0, 7.0)];
+        let cases = [
+            LegendTestCase {
+                chart_area: Rect::new(0, 0, 100, 100),
+                hidden_legend_constraints: (Constraint::Ratio(1, 4), Constraint::Ratio(1, 4)),
+                legend_area: Some(Rect::new(88, 0, 12, 12)),
+            },
+            LegendTestCase {
+                chart_area: Rect::new(0, 0, 100, 100),
+                hidden_legend_constraints: (Constraint::Ratio(1, 10), Constraint::Ratio(1, 4)),
+                legend_area: None,
+            },
+        ];
+        for case in &cases {
+            let datasets = (0..10)
+                .map(|i| {
+                    let name = format!("Dataset #{}", i);
+                    Dataset::default().name(name).data(&data)
+                })
+                .collect::<Vec<_>>();
+            let chart = Chart::new(datasets)
+                .x_axis(Axis::default().title("X axis"))
+                .y_axis(Axis::default().title("Y axis"))
+                .hidden_legend_constraints(case.hidden_legend_constraints);
+            let layout = chart.layout(case.chart_area);
+            assert_eq!(layout.legend_area, case.legend_area);
+        }
+    }
+}
diff --git a/src/ratatui/widgets/clear.rs b/src/ratatui/widgets/clear.rs
new file mode 100644
index 00000000..a7c8d34b
--- /dev/null
+++ b/src/ratatui/widgets/clear.rs
@@ -0,0 +1,37 @@
+use crate::ratatui::{buffer::Buffer, layout::Rect, widgets::Widget};
+
+/// A widget to clear/reset a certain area to allow overdrawing (e.g. for popups).
+///
+/// This widget **cannot be used to clear the terminal on the first render** as `ratatui` assumes the
+/// render area is empty. Use [`crate::Terminal::clear`] instead.
+///
+/// # Examples
+///
+/// ```
+/// # use ratatui::widgets::{Clear, Block, Borders};
+/// # use ratatui::layout::Rect;
+/// # use ratatui::Frame;
+/// # use ratatui::backend::Backend;
+/// fn draw_on_clear<B: Backend>(f: &mut Frame<B>, area: Rect) {
+///     let block = Block::default().title("Block").borders(Borders::ALL);
+///     f.render_widget(Clear, area); // <- this will clear/reset the area first
+///     f.render_widget(block, area); // now render the block widget
+/// }
+/// ```
+///
+/// # Popup Example
+///
+/// For a more complete example how to utilize `Clear` to realize popups see
+/// the example `examples/popup.rs`
+#[derive(Debug, Clone)]
+pub struct Clear;
+
+impl Widget for Clear {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        for x in area.left()..area.right() {
+            for y in area.top()..area.bottom() {
+                buf.get_mut(x, y).reset();
+            }
+        }
+    }
+}
diff --git a/src/ratatui/widgets/gauge.rs b/src/ratatui/widgets/gauge.rs
new file mode 100644
index 00000000..6b53b975
--- /dev/null
+++ b/src/ratatui/widgets/gauge.rs
@@ -0,0 +1,313 @@
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    style::{Color, Style},
+    symbols,
+    text::{Span, Spans},
+    widgets::{Block, Widget},
+};
+
+/// A widget to display a task progress.
+///
+/// # Examples:
+///
+/// ```
+/// # use ratatui::widgets::{Widget, Gauge, Block, Borders};
+/// # use ratatui::style::{Style, Color, Modifier};
+/// Gauge::default()
+///     .block(Block::default().borders(Borders::ALL).title("Progress"))
+///     .gauge_style(Style::default().fg(Color::White).bg(Color::Black).add_modifier(Modifier::ITALIC))
+///     .percent(20);
+/// ```
+#[derive(Debug, Clone)]
+pub struct Gauge<'a> {
+    block: Option<Block<'a>>,
+    ratio: f64,
+    label: Option<Span<'a>>,
+    use_unicode: bool,
+    style: Style,
+    gauge_style: Style,
+}
+
+impl<'a> Default for Gauge<'a> {
+    fn default() -> Gauge<'a> {
+        Gauge {
+            block: None,
+            ratio: 0.0,
+            label: None,
+            use_unicode: false,
+            style: Style::default(),
+            gauge_style: Style::default(),
+        }
+    }
+}
+
+impl<'a> Gauge<'a> {
+    pub fn block(mut self, block: Block<'a>) -> Gauge<'a> {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn percent(mut self, percent: u16) -> Gauge<'a> {
+        assert!(
+            percent <= 100,
+            "Percentage should be between 0 and 100 inclusively."
+        );
+        self.ratio = f64::from(percent) / 100.0;
+        self
+    }
+
+    /// Sets ratio ([0.0, 1.0]) directly.
+    pub fn ratio(mut self, ratio: f64) -> Gauge<'a> {
+        assert!(
+            (0.0..=1.0).contains(&ratio),
+            "Ratio should be between 0 and 1 inclusively."
+        );
+        self.ratio = ratio;
+        self
+    }
+
+    pub fn label<T>(mut self, label: T) -> Gauge<'a>
+    where
+        T: Into<Span<'a>>,
+    {
+        self.label = Some(label.into());
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Gauge<'a> {
+        self.style = style;
+        self
+    }
+
+    pub fn gauge_style(mut self, style: Style) -> Gauge<'a> {
+        self.gauge_style = style;
+        self
+    }
+
+    pub fn use_unicode(mut self, unicode: bool) -> Gauge<'a> {
+        self.use_unicode = unicode;
+        self
+    }
+}
+
+impl<'a> Widget for Gauge<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        let gauge_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+        buf.set_style(gauge_area, self.gauge_style);
+        if gauge_area.height < 1 {
+            return;
+        }
+
+        // compute label value and its position
+        // label is put at the center of the gauge_area
+        let label = {
+            let pct = f64::round(self.ratio * 100.0);
+            self.label
+                .unwrap_or_else(|| Span::from(format!("{}%", pct)))
+        };
+        let clamped_label_width = gauge_area.width.min(label.width() as u16);
+        let label_col = gauge_area.left() + (gauge_area.width - clamped_label_width) / 2;
+        let label_row = gauge_area.top() + gauge_area.height / 2;
+
+        // the gauge will be filled proportionally to the ratio
+        let filled_width = f64::from(gauge_area.width) * self.ratio;
+        let end = if self.use_unicode {
+            gauge_area.left() + filled_width.floor() as u16
+        } else {
+            gauge_area.left() + filled_width.round() as u16
+        };
+        for y in gauge_area.top()..gauge_area.bottom() {
+            // render the filled area (left to end)
+            for x in gauge_area.left()..end {
+                // spaces are needed to apply the background styling
+                buf.get_mut(x, y)
+                    .set_symbol(" ")
+                    .set_fg(self.gauge_style.bg.unwrap_or(Color::Reset))
+                    .set_bg(self.gauge_style.fg.unwrap_or(Color::Reset));
+            }
+            if self.use_unicode && self.ratio < 1.0 {
+                buf.get_mut(end, y)
+                    .set_symbol(get_unicode_block(filled_width % 1.0));
+            }
+        }
+        // set the span
+        buf.set_span(label_col, label_row, &label, clamped_label_width);
+    }
+}
+
+fn get_unicode_block<'a>(frac: f64) -> &'a str {
+    match (frac * 8.0).round() as u16 {
+        1 => symbols::block::ONE_EIGHTH,
+        2 => symbols::block::ONE_QUARTER,
+        3 => symbols::block::THREE_EIGHTHS,
+        4 => symbols::block::HALF,
+        5 => symbols::block::FIVE_EIGHTHS,
+        6 => symbols::block::THREE_QUARTERS,
+        7 => symbols::block::SEVEN_EIGHTHS,
+        8 => symbols::block::FULL,
+        _ => " ",
+    }
+}
+
+/// A compact widget to display a task progress over a single line.
+///
+/// # Examples:
+///
+/// ```
+/// # use ratatui::widgets::{Widget, LineGauge, Block, Borders};
+/// # use ratatui::style::{Style, Color, Modifier};
+/// # use ratatui::symbols;
+/// LineGauge::default()
+///     .block(Block::default().borders(Borders::ALL).title("Progress"))
+///     .gauge_style(Style::default().fg(Color::White).bg(Color::Black).add_modifier(Modifier::BOLD))
+///     .line_set(symbols::line::THICK)
+///     .ratio(0.4);
+/// ```
+pub struct LineGauge<'a> {
+    block: Option<Block<'a>>,
+    ratio: f64,
+    label: Option<Spans<'a>>,
+    line_set: symbols::line::Set,
+    style: Style,
+    gauge_style: Style,
+}
+
+impl<'a> Default for LineGauge<'a> {
+    fn default() -> Self {
+        Self {
+            block: None,
+            ratio: 0.0,
+            label: None,
+            style: Style::default(),
+            line_set: symbols::line::NORMAL,
+            gauge_style: Style::default(),
+        }
+    }
+}
+
+impl<'a> LineGauge<'a> {
+    pub fn block(mut self, block: Block<'a>) -> Self {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn ratio(mut self, ratio: f64) -> Self {
+        assert!(
+            (0.0..=1.0).contains(&ratio),
+            "Ratio should be between 0 and 1 inclusively."
+        );
+        self.ratio = ratio;
+        self
+    }
+
+    pub fn line_set(mut self, set: symbols::line::Set) -> Self {
+        self.line_set = set;
+        self
+    }
+
+    pub fn label<T>(mut self, label: T) -> Self
+    where
+        T: Into<Spans<'a>>,
+    {
+        self.label = Some(label.into());
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+
+    pub fn gauge_style(mut self, style: Style) -> Self {
+        self.gauge_style = style;
+        self
+    }
+}
+
+impl<'a> Widget for LineGauge<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        let gauge_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        if gauge_area.height < 1 {
+            return;
+        }
+
+        let ratio = self.ratio;
+        let label = self
+            .label
+            .unwrap_or_else(move || Spans::from(format!("{:.0}%", ratio * 100.0)));
+        let (col, row) = buf.set_spans(
+            gauge_area.left(),
+            gauge_area.top(),
+            &label,
+            gauge_area.width,
+        );
+        let start = col + 1;
+        if start >= gauge_area.right() {
+            return;
+        }
+
+        let end = start
+            + (f64::from(gauge_area.right().saturating_sub(start)) * self.ratio).floor() as u16;
+        for col in start..end {
+            buf.get_mut(col, row)
+                .set_symbol(self.line_set.horizontal)
+                .set_style(Style {
+                    fg: self.gauge_style.fg,
+                    bg: None,
+                    add_modifier: self.gauge_style.add_modifier,
+                    sub_modifier: self.gauge_style.sub_modifier,
+                });
+        }
+        for col in end..gauge_area.right() {
+            buf.get_mut(col, row)
+                .set_symbol(self.line_set.horizontal)
+                .set_style(Style {
+                    fg: self.gauge_style.bg,
+                    bg: None,
+                    add_modifier: self.gauge_style.add_modifier,
+                    sub_modifier: self.gauge_style.sub_modifier,
+                });
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn gauge_invalid_percentage() {
+        Gauge::default().percent(110);
+    }
+
+    #[test]
+    #[should_panic]
+    fn gauge_invalid_ratio_upper_bound() {
+        Gauge::default().ratio(1.1);
+    }
+
+    #[test]
+    #[should_panic]
+    fn gauge_invalid_ratio_lower_bound() {
+        Gauge::default().ratio(-0.5);
+    }
+}
diff --git a/src/ratatui/widgets/list.rs b/src/ratatui/widgets/list.rs
new file mode 100644
index 00000000..9608d299
--- /dev/null
+++ b/src/ratatui/widgets/list.rs
@@ -0,0 +1,268 @@
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::{Corner, Rect},
+    style::Style,
+    text::Text,
+    widgets::{Block, StatefulWidget, Widget},
+};
+use unicode_width::UnicodeWidthStr;
+
+#[derive(Debug, Clone, Default)]
+pub struct ListState {
+    offset: usize,
+    selected: Option<usize>,
+}
+
+impl ListState {
+    pub fn selected(&self) -> Option<usize> {
+        self.selected
+    }
+
+    pub fn select(&mut self, index: Option<usize>) {
+        self.selected = index;
+        if index.is_none() {
+            self.offset = 0;
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ListItem<'a> {
+    content: Text<'a>,
+    style: Style,
+}
+
+impl<'a> ListItem<'a> {
+    pub fn new<T>(content: T) -> ListItem<'a>
+    where
+        T: Into<Text<'a>>,
+    {
+        ListItem {
+            content: content.into(),
+            style: Style::default(),
+        }
+    }
+
+    pub fn style(mut self, style: Style) -> ListItem<'a> {
+        self.style = style;
+        self
+    }
+
+    pub fn height(&self) -> usize {
+        self.content.height()
+    }
+
+    pub fn width(&self) -> usize {
+        self.content.width()
+    }
+}
+
+/// A widget to display several items among which one can be selected (optional)
+///
+/// # Examples
+///
+/// ```
+/// # use ratatui::widgets::{Block, Borders, List, ListItem};
+/// # use ratatui::style::{Style, Color, Modifier};
+/// let items = [ListItem::new("Item 1"), ListItem::new("Item 2"), ListItem::new("Item 3")];
+/// List::new(items)
+///     .block(Block::default().title("List").borders(Borders::ALL))
+///     .style(Style::default().fg(Color::White))
+///     .highlight_style(Style::default().add_modifier(Modifier::ITALIC))
+///     .highlight_symbol(">>");
+/// ```
+#[derive(Debug, Clone)]
+pub struct List<'a> {
+    block: Option<Block<'a>>,
+    items: Vec<ListItem<'a>>,
+    /// Style used as a base style for the widget
+    style: Style,
+    start_corner: Corner,
+    /// Style used to render selected item
+    highlight_style: Style,
+    /// Symbol in front of the selected item (Shift all items to the right)
+    highlight_symbol: Option<&'a str>,
+    /// Whether to repeat the highlight symbol for each line of the selected item
+    repeat_highlight_symbol: bool,
+}
+
+impl<'a> List<'a> {
+    pub fn new<T>(items: T) -> List<'a>
+    where
+        T: Into<Vec<ListItem<'a>>>,
+    {
+        List {
+            block: None,
+            style: Style::default(),
+            items: items.into(),
+            start_corner: Corner::TopLeft,
+            highlight_style: Style::default(),
+            highlight_symbol: None,
+            repeat_highlight_symbol: false,
+        }
+    }
+
+    pub fn block(mut self, block: Block<'a>) -> List<'a> {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> List<'a> {
+        self.style = style;
+        self
+    }
+
+    pub fn highlight_symbol(mut self, highlight_symbol: &'a str) -> List<'a> {
+        self.highlight_symbol = Some(highlight_symbol);
+        self
+    }
+
+    pub fn highlight_style(mut self, style: Style) -> List<'a> {
+        self.highlight_style = style;
+        self
+    }
+
+    pub fn repeat_highlight_symbol(mut self, repeat: bool) -> List<'a> {
+        self.repeat_highlight_symbol = repeat;
+        self
+    }
+
+    pub fn start_corner(mut self, corner: Corner) -> List<'a> {
+        self.start_corner = corner;
+        self
+    }
+
+    fn get_items_bounds(
+        &self,
+        selected: Option<usize>,
+        offset: usize,
+        max_height: usize,
+    ) -> (usize, usize) {
+        let offset = offset.min(self.items.len().saturating_sub(1));
+        let mut start = offset;
+        let mut end = offset;
+        let mut height = 0;
+        for item in self.items.iter().skip(offset) {
+            if height + item.height() > max_height {
+                break;
+            }
+            height += item.height();
+            end += 1;
+        }
+
+        let selected = selected.unwrap_or(0).min(self.items.len() - 1);
+        while selected >= end {
+            height = height.saturating_add(self.items[end].height());
+            end += 1;
+            while height > max_height {
+                height = height.saturating_sub(self.items[start].height());
+                start += 1;
+            }
+        }
+        while selected < start {
+            start -= 1;
+            height = height.saturating_add(self.items[start].height());
+            while height > max_height {
+                end -= 1;
+                height = height.saturating_sub(self.items[end].height());
+            }
+        }
+        (start, end)
+    }
+}
+
+impl<'a> StatefulWidget for List<'a> {
+    type State = ListState;
+
+    fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+        buf.set_style(area, self.style);
+        let list_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        if list_area.width < 1 || list_area.height < 1 {
+            return;
+        }
+
+        if self.items.is_empty() {
+            return;
+        }
+        let list_height = list_area.height as usize;
+
+        let (start, end) = self.get_items_bounds(state.selected, state.offset, list_height);
+        state.offset = start;
+
+        let highlight_symbol = self.highlight_symbol.unwrap_or("");
+        let blank_symbol = " ".repeat(highlight_symbol.width());
+
+        let mut current_height = 0;
+        let has_selection = state.selected.is_some();
+        for (i, item) in self
+            .items
+            .iter_mut()
+            .enumerate()
+            .skip(state.offset)
+            .take(end - start)
+        {
+            let (x, y) = match self.start_corner {
+                Corner::BottomLeft => {
+                    current_height += item.height() as u16;
+                    (list_area.left(), list_area.bottom() - current_height)
+                }
+                _ => {
+                    let pos = (list_area.left(), list_area.top() + current_height);
+                    current_height += item.height() as u16;
+                    pos
+                }
+            };
+            let area = Rect {
+                x,
+                y,
+                width: list_area.width,
+                height: item.height() as u16,
+            };
+            let item_style = self.style.patch(item.style);
+            buf.set_style(area, item_style);
+
+            let is_selected = state.selected.map(|s| s == i).unwrap_or(false);
+            for (j, line) in item.content.lines.iter().enumerate() {
+                // if the item is selected, we need to display the highlight symbol:
+                // - either for the first line of the item only,
+                // - or for each line of the item if the appropriate option is set
+                let symbol = if is_selected && (j == 0 || self.repeat_highlight_symbol) {
+                    highlight_symbol
+                } else {
+                    &blank_symbol
+                };
+                let (elem_x, max_element_width) = if has_selection {
+                    let (elem_x, _) = buf.set_stringn(
+                        x,
+                        y + j as u16,
+                        symbol,
+                        list_area.width as usize,
+                        item_style,
+                    );
+                    (elem_x, (list_area.width - (elem_x - x)))
+                } else {
+                    (x, list_area.width)
+                };
+                buf.set_spans(elem_x, y + j as u16, line, max_element_width);
+            }
+            if is_selected {
+                buf.set_style(area, self.highlight_style);
+            }
+        }
+    }
+}
+
+impl<'a> Widget for List<'a> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let mut state = ListState::default();
+        StatefulWidget::render(self, area, buf, &mut state);
+    }
+}
diff --git a/src/ratatui/widgets/mod.rs b/src/ratatui/widgets/mod.rs
new file mode 100644
index 00000000..5a6167b8
--- /dev/null
+++ b/src/ratatui/widgets/mod.rs
@@ -0,0 +1,184 @@
+//! `widgets` is a collection of types that implement [`Widget`] or [`StatefulWidget`] or both.
+//!
+//! All widgets are implemented using the builder pattern and are consumable objects. They are not
+//! meant to be stored but used as *commands* to draw common figures in the UI.
+//!
+//! The available widgets are:
+//! - [`Block`]
+//! - [`Tabs`]
+//! - [`List`]
+//! - [`Table`]
+//! - [`Paragraph`]
+//! - [`Chart`]
+//! - [`BarChart`]
+//! - [`Gauge`]
+//! - [`Sparkline`]
+//! - [`Clear`]
+
+mod barchart;
+mod block;
+pub mod canvas;
+mod chart;
+mod clear;
+mod gauge;
+mod list;
+mod paragraph;
+mod reflow;
+mod sparkline;
+mod table;
+mod tabs;
+
+pub use self::barchart::BarChart;
+pub use self::block::{Block, BorderType};
+pub use self::chart::{Axis, Chart, Dataset, GraphType};
+pub use self::clear::Clear;
+pub use self::gauge::{Gauge, LineGauge};
+pub use self::list::{List, ListItem, ListState};
+pub use self::paragraph::{Paragraph, Wrap};
+pub use self::sparkline::Sparkline;
+pub use self::table::{Cell, Row, Table, TableState};
+pub use self::tabs::Tabs;
+
+use crate::ratatui::{buffer::Buffer, layout::Rect};
+use bitflags::bitflags;
+
+bitflags! {
+    /// Bitflags that can be composed to set the visible borders essentially on the block widget.
+    pub struct Borders: u8 {
+        /// Show no border (default)
+        const NONE   = 0b0000;
+        /// Show the top border
+        const TOP    = 0b0001;
+        /// Show the right border
+        const RIGHT  = 0b0010;
+        /// Show the bottom border
+        const BOTTOM = 0b0100;
+        /// Show the left border
+        const LEFT   = 0b1000;
+        /// Show all borders
+        const ALL = Self::TOP.bits | Self::RIGHT.bits | Self::BOTTOM.bits | Self::LEFT.bits;
+    }
+}
+
+/// Base requirements for a Widget
+pub trait Widget {
+    /// Draws the current state of the widget in the given buffer. That is the only method required
+    /// to implement a custom widget.
+    fn render(self, area: Rect, buf: &mut Buffer);
+}
+
+/// A `StatefulWidget` is a widget that can take advantage of some local state to remember things
+/// between two draw calls.
+///
+/// Most widgets can be drawn directly based on the input parameters. However, some features may
+/// require some kind of associated state to be implemented.
+///
+/// For example, the [`List`] widget can highlight the item currently selected. This can be
+/// translated in an offset, which is the number of elements to skip in order to have the selected
+/// item within the viewport currently allocated to this widget. The widget can therefore only
+/// provide the following behavior: whenever the selected item is out of the viewport scroll to a
+/// predefined position (making the selected item the last viewable item or the one in the middle
+/// for example). Nonetheless, if the widget has access to the last computed offset then it can
+/// implement a natural scrolling experience where the last offset is reused until the selected
+/// item is out of the viewport.
+///
+/// ## Examples
+///
+/// ```rust,no_run
+/// # use std::io;
+/// # use ratatui::Terminal;
+/// # use ratatui::backend::{Backend, TestBackend};
+/// # use ratatui::widgets::{Widget, List, ListItem, ListState};
+///
+/// // Let's say we have some events to display.
+/// struct Events {
+///     // `items` is the state managed by your application.
+///     items: Vec<String>,
+///     // `state` is the state that can be modified by the UI. It stores the index of the selected
+///     // item as well as the offset computed during the previous draw call (used to implement
+///     // natural scrolling).
+///     state: ListState
+/// }
+///
+/// impl Events {
+///     fn new(items: Vec<String>) -> Events {
+///         Events {
+///             items,
+///             state: ListState::default(),
+///         }
+///     }
+///
+///     pub fn set_items(&mut self, items: Vec<String>) {
+///         self.items = items;
+///         // We reset the state as the associated items have changed. This effectively reset
+///         // the selection as well as the stored offset.
+///         self.state = ListState::default();
+///     }
+///
+///     // Select the next item. This will not be reflected until the widget is drawn in the
+///     // `Terminal::draw` callback using `Frame::render_stateful_widget`.
+///     pub fn next(&mut self) {
+///         let i = match self.state.selected() {
+///             Some(i) => {
+///                 if i >= self.items.len() - 1 {
+///                     0
+///                 } else {
+///                     i + 1
+///                 }
+///             }
+///             None => 0,
+///         };
+///         self.state.select(Some(i));
+///     }
+///
+///     // Select the previous item. This will not be reflected until the widget is drawn in the
+///     // `Terminal::draw` callback using `Frame::render_stateful_widget`.
+///     pub fn previous(&mut self) {
+///         let i = match self.state.selected() {
+///             Some(i) => {
+///                 if i == 0 {
+///                     self.items.len() - 1
+///                 } else {
+///                     i - 1
+///                 }
+///             }
+///             None => 0,
+///         };
+///         self.state.select(Some(i));
+///     }
+///
+///     // Unselect the currently selected item if any. The implementation of `ListState` makes
+///     // sure that the stored offset is also reset.
+///     pub fn unselect(&mut self) {
+///         self.state.select(None);
+///     }
+/// }
+///
+/// # let backend = TestBackend::new(5, 5);
+/// # let mut terminal = Terminal::new(backend).unwrap();
+///
+/// let mut events = Events::new(vec![
+///     String::from("Item 1"),
+///     String::from("Item 2")
+/// ]);
+///
+/// loop {
+///     terminal.draw(|f| {
+///         // The items managed by the application are transformed to something
+///         // that is understood by ratatui.
+///         let items: Vec<ListItem>= events.items.iter().map(|i| ListItem::new(i.as_ref())).collect();
+///         // The `List` widget is then built with those items.
+///         let list = List::new(items);
+///         // Finally the widget is rendered using the associated state. `events.state` is
+///         // effectively the only thing that we will "remember" from this draw call.
+///         f.render_stateful_widget(list, f.size(), &mut events.state);
+///     });
+///
+///     // In response to some input events or an external http request or whatever:
+///     events.next();
+/// }
+/// ```
+pub trait StatefulWidget {
+    type State;
+    fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State);
+}
diff --git a/src/ratatui/widgets/paragraph.rs b/src/ratatui/widgets/paragraph.rs
new file mode 100644
index 00000000..5edfe08e
--- /dev/null
+++ b/src/ratatui/widgets/paragraph.rs
@@ -0,0 +1,214 @@
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::{Alignment, Rect},
+    style::Style,
+    text::{StyledGrapheme, Text},
+    widgets::{
+        reflow::{LineComposer, LineTruncator, WordWrapper},
+        Block, Widget,
+    },
+};
+use std::iter;
+use unicode_width::UnicodeWidthStr;
+
+fn get_line_offset(line_width: u16, text_area_width: u16, alignment: Alignment) -> u16 {
+    match alignment {
+        Alignment::Center => (text_area_width / 2).saturating_sub(line_width / 2),
+        Alignment::Right => text_area_width.saturating_sub(line_width),
+        Alignment::Left => 0,
+    }
+}
+
+/// A widget to display some text.
+///
+/// # Examples
+///
+/// ```
+/// # use ratatui::text::{Text, Spans, Span};
+/// # use ratatui::widgets::{Block, Borders, Paragraph, Wrap};
+/// # use ratatui::style::{Style, Color, Modifier};
+/// # use ratatui::layout::{Alignment};
+/// let text = vec![
+///     Spans::from(vec![
+///         Span::raw("First"),
+///         Span::styled("line",Style::default().add_modifier(Modifier::ITALIC)),
+///         Span::raw("."),
+///     ]),
+///     Spans::from(Span::styled("Second line", Style::default().fg(Color::Red))),
+/// ];
+/// Paragraph::new(text)
+///     .block(Block::default().title("Paragraph").borders(Borders::ALL))
+///     .style(Style::default().fg(Color::White).bg(Color::Black))
+///     .alignment(Alignment::Center)
+///     .wrap(Wrap { trim: true });
+/// ```
+#[derive(Debug, Clone)]
+pub struct Paragraph<'a> {
+    /// A block to wrap the widget in
+    block: Option<Block<'a>>,
+    /// Widget style
+    style: Style,
+    /// How to wrap the text
+    wrap: Option<Wrap>,
+    /// The text to display
+    text: Text<'a>,
+    /// Scroll
+    scroll: (u16, u16),
+    /// Alignment of the text
+    alignment: Alignment,
+}
+
+/// Describes how to wrap text across lines.
+///
+/// ## Examples
+///
+/// ```
+/// # use ratatui::widgets::{Paragraph, Wrap};
+/// # use ratatui::text::Text;
+/// let bullet_points = Text::from(r#"Some indented points:
+///     - First thing goes here and is long so that it wraps
+///     - Here is another point that is long enough to wrap"#);
+///
+/// // With leading spaces trimmed (window width of 30 chars):
+/// Paragraph::new(bullet_points.clone()).wrap(Wrap { trim: true });
+/// // Some indented points:
+/// // - First thing goes here and is
+/// // long so that it wraps
+/// // - Here is another point that
+/// // is long enough to wrap
+///
+/// // But without trimming, indentation is preserved:
+/// Paragraph::new(bullet_points).wrap(Wrap { trim: false });
+/// // Some indented points:
+/// //     - First thing goes here
+/// // and is long so that it wraps
+/// //     - Here is another point
+/// // that is long enough to wrap
+/// ```
+#[derive(Debug, Clone, Copy)]
+pub struct Wrap {
+    /// Should leading whitespace be trimmed
+    pub trim: bool,
+}
+
+impl<'a> Paragraph<'a> {
+    pub fn new<T>(text: T) -> Paragraph<'a>
+    where
+        T: Into<Text<'a>>,
+    {
+        Paragraph {
+            block: None,
+            style: Default::default(),
+            wrap: None,
+            text: text.into(),
+            scroll: (0, 0),
+            alignment: Alignment::Left,
+        }
+    }
+
+    pub fn block(mut self, block: Block<'a>) -> Paragraph<'a> {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Paragraph<'a> {
+        self.style = style;
+        self
+    }
+
+    pub fn wrap(mut self, wrap: Wrap) -> Paragraph<'a> {
+        self.wrap = Some(wrap);
+        self
+    }
+
+    pub fn scroll(mut self, offset: (u16, u16)) -> Paragraph<'a> {
+        self.scroll = offset;
+        self
+    }
+
+    pub fn alignment(mut self, alignment: Alignment) -> Paragraph<'a> {
+        self.alignment = alignment;
+        self
+    }
+}
+
+impl<'a> Widget for Paragraph<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        let text_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        if text_area.height < 1 {
+            return;
+        }
+
+        let style = self.style;
+        let mut styled = self.text.lines.iter().flat_map(|spans| {
+            spans
+                .0
+                .iter()
+                .flat_map(|span| span.styled_graphemes(style))
+                // Required given the way composers work but might be refactored out if we change
+                // composers to operate on lines instead of a stream of graphemes.
+                .chain(iter::once(StyledGrapheme {
+                    symbol: "\n",
+                    style: self.style,
+                }))
+        });
+
+        let mut line_composer: Box<dyn LineComposer> = if let Some(Wrap { trim }) = self.wrap {
+            Box::new(WordWrapper::new(&mut styled, text_area.width, trim))
+        } else {
+            let mut line_composer = Box::new(LineTruncator::new(&mut styled, text_area.width));
+            if let Alignment::Left = self.alignment {
+                line_composer.set_horizontal_offset(self.scroll.1);
+            }
+            line_composer
+        };
+        let mut y = 0;
+        while let Some((current_line, current_line_width)) = line_composer.next_line() {
+            if y >= self.scroll.0 {
+                let mut x = get_line_offset(current_line_width, text_area.width, self.alignment);
+                for StyledGrapheme { symbol, style } in current_line {
+                    let width = symbol.width();
+                    if width == 0 {
+                        continue;
+                    }
+                    buf.get_mut(text_area.left() + x, text_area.top() + y - self.scroll.0)
+                        .set_symbol(if symbol.is_empty() {
+                            // If the symbol is empty, the last char which rendered last time will
+                            // leave on the line. It's a quick fix.
+                            " "
+                        } else {
+                            symbol
+                        })
+                        .set_style(*style);
+                    x += width as u16;
+                }
+            }
+            y += 1;
+            if y >= text_area.height + self.scroll.0 {
+                break;
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn zero_width_char_at_end_of_line() {
+        let line = "foo\0";
+        let paragraph = Paragraph::new(line);
+        let mut buf = Buffer::with_lines(vec![line]);
+        paragraph.render(*buf.area(), &mut buf);
+    }
+}
diff --git a/src/ratatui/widgets/reflow.rs b/src/ratatui/widgets/reflow.rs
new file mode 100644
index 00000000..3806b33e
--- /dev/null
+++ b/src/ratatui/widgets/reflow.rs
@@ -0,0 +1,534 @@
+use crate::ratatui::text::StyledGrapheme;
+use unicode_segmentation::UnicodeSegmentation;
+use unicode_width::UnicodeWidthStr;
+
+const NBSP: &str = "\u{00a0}";
+
+/// A state machine to pack styled symbols into lines.
+/// Cannot implement it as Iterator since it yields slices of the internal buffer (need streaming
+/// iterators for that).
+pub trait LineComposer<'a> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)>;
+}
+
+/// A state machine that wraps lines on word boundaries.
+pub struct WordWrapper<'a, 'b> {
+    symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+    max_line_width: u16,
+    current_line: Vec<StyledGrapheme<'a>>,
+    next_line: Vec<StyledGrapheme<'a>>,
+    /// Removes the leading whitespace from lines
+    trim: bool,
+}
+
+impl<'a, 'b> WordWrapper<'a, 'b> {
+    pub fn new(
+        symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+        max_line_width: u16,
+        trim: bool,
+    ) -> WordWrapper<'a, 'b> {
+        WordWrapper {
+            symbols,
+            max_line_width,
+            current_line: vec![],
+            next_line: vec![],
+            trim,
+        }
+    }
+}
+
+impl<'a, 'b> LineComposer<'a> for WordWrapper<'a, 'b> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)> {
+        if self.max_line_width == 0 {
+            return None;
+        }
+        std::mem::swap(&mut self.current_line, &mut self.next_line);
+        self.next_line.truncate(0);
+
+        let mut current_line_width = self
+            .current_line
+            .iter()
+            .map(|StyledGrapheme { symbol, .. }| symbol.width() as u16)
+            .sum();
+
+        let mut symbols_to_last_word_end: usize = 0;
+        let mut width_to_last_word_end: u16 = 0;
+        let mut prev_whitespace = false;
+        let mut symbols_exhausted = true;
+        for StyledGrapheme { symbol, style } in &mut self.symbols {
+            symbols_exhausted = false;
+            let symbol_whitespace = symbol.chars().all(&char::is_whitespace) && symbol != NBSP;
+
+            // Ignore characters wider that the total max width.
+            if symbol.width() as u16 > self.max_line_width
+                // Skip leading whitespace when trim is enabled.
+                || self.trim && symbol_whitespace && symbol != "\n" && current_line_width == 0
+            {
+                continue;
+            }
+
+            // Break on newline and discard it.
+            if symbol == "\n" {
+                if prev_whitespace {
+                    current_line_width = width_to_last_word_end;
+                    self.current_line.truncate(symbols_to_last_word_end);
+                }
+                break;
+            }
+
+            // Mark the previous symbol as word end.
+            if symbol_whitespace && !prev_whitespace {
+                symbols_to_last_word_end = self.current_line.len();
+                width_to_last_word_end = current_line_width;
+            }
+
+            self.current_line.push(StyledGrapheme { symbol, style });
+            current_line_width += symbol.width() as u16;
+
+            if current_line_width > self.max_line_width {
+                // If there was no word break in the text, wrap at the end of the line.
+                let (truncate_at, truncated_width) = if symbols_to_last_word_end != 0 {
+                    (symbols_to_last_word_end, width_to_last_word_end)
+                } else {
+                    (self.current_line.len() - 1, self.max_line_width)
+                };
+
+                // Push the remainder to the next line but strip leading whitespace:
+                {
+                    let remainder = &self.current_line[truncate_at..];
+                    if let Some(remainder_nonwhite) =
+                        remainder.iter().position(|StyledGrapheme { symbol, .. }| {
+                            !symbol.chars().all(&char::is_whitespace)
+                        })
+                    {
+                        self.next_line
+                            .extend_from_slice(&remainder[remainder_nonwhite..]);
+                    }
+                }
+                self.current_line.truncate(truncate_at);
+                current_line_width = truncated_width;
+                break;
+            }
+
+            prev_whitespace = symbol_whitespace;
+        }
+
+        // Even if the iterator is exhausted, pass the previous remainder.
+        if symbols_exhausted && self.current_line.is_empty() {
+            None
+        } else {
+            Some((&self.current_line[..], current_line_width))
+        }
+    }
+}
+
+/// A state machine that truncates overhanging lines.
+pub struct LineTruncator<'a, 'b> {
+    symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+    max_line_width: u16,
+    current_line: Vec<StyledGrapheme<'a>>,
+    /// Record the offset to skip render
+    horizontal_offset: u16,
+}
+
+impl<'a, 'b> LineTruncator<'a, 'b> {
+    pub fn new(
+        symbols: &'b mut dyn Iterator<Item = StyledGrapheme<'a>>,
+        max_line_width: u16,
+    ) -> LineTruncator<'a, 'b> {
+        LineTruncator {
+            symbols,
+            max_line_width,
+            horizontal_offset: 0,
+            current_line: vec![],
+        }
+    }
+
+    pub fn set_horizontal_offset(&mut self, horizontal_offset: u16) {
+        self.horizontal_offset = horizontal_offset;
+    }
+}
+
+impl<'a, 'b> LineComposer<'a> for LineTruncator<'a, 'b> {
+    fn next_line(&mut self) -> Option<(&[StyledGrapheme<'a>], u16)> {
+        if self.max_line_width == 0 {
+            return None;
+        }
+
+        self.current_line.truncate(0);
+        let mut current_line_width = 0;
+
+        let mut skip_rest = false;
+        let mut symbols_exhausted = true;
+        let mut horizontal_offset = self.horizontal_offset as usize;
+        for StyledGrapheme { symbol, style } in &mut self.symbols {
+            symbols_exhausted = false;
+
+            // Ignore characters wider that the total max width.
+            if symbol.width() as u16 > self.max_line_width {
+                continue;
+            }
+
+            // Break on newline and discard it.
+            if symbol == "\n" {
+                break;
+            }
+
+            if current_line_width + symbol.width() as u16 > self.max_line_width {
+                // Exhaust the remainder of the line.
+                skip_rest = true;
+                break;
+            }
+
+            let symbol = if horizontal_offset == 0 {
+                symbol
+            } else {
+                let w = symbol.width();
+                if w > horizontal_offset {
+                    let t = trim_offset(symbol, horizontal_offset);
+                    horizontal_offset = 0;
+                    t
+                } else {
+                    horizontal_offset -= w;
+                    ""
+                }
+            };
+            current_line_width += symbol.width() as u16;
+            self.current_line.push(StyledGrapheme { symbol, style });
+        }
+
+        if skip_rest {
+            for StyledGrapheme { symbol, .. } in &mut self.symbols {
+                if symbol == "\n" {
+                    break;
+                }
+            }
+        }
+
+        if symbols_exhausted && self.current_line.is_empty() {
+            None
+        } else {
+            Some((&self.current_line[..], current_line_width))
+        }
+    }
+}
+
+/// This function will return a str slice which start at specified offset.
+/// As src is a unicode str, start offset has to be calculated with each character.
+fn trim_offset(src: &str, mut offset: usize) -> &str {
+    let mut start = 0;
+    for c in UnicodeSegmentation::graphemes(src, true) {
+        let w = c.width();
+        if w <= offset {
+            offset -= w;
+            start += c.len();
+        } else {
+            break;
+        }
+    }
+    &src[start..]
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use unicode_segmentation::UnicodeSegmentation;
+
+    enum Composer {
+        WordWrapper { trim: bool },
+        LineTruncator,
+    }
+
+    fn run_composer(which: Composer, text: &str, text_area_width: u16) -> (Vec<String>, Vec<u16>) {
+        let style = Default::default();
+        let mut styled =
+            UnicodeSegmentation::graphemes(text, true).map(|g| StyledGrapheme { symbol: g, style });
+        let mut composer: Box<dyn LineComposer> = match which {
+            Composer::WordWrapper { trim } => {
+                Box::new(WordWrapper::new(&mut styled, text_area_width, trim))
+            }
+            Composer::LineTruncator => Box::new(LineTruncator::new(&mut styled, text_area_width)),
+        };
+        let mut lines = vec![];
+        let mut widths = vec![];
+        while let Some((styled, width)) = composer.next_line() {
+            let line = styled
+                .iter()
+                .map(|StyledGrapheme { symbol, .. }| *symbol)
+                .collect::<String>();
+            assert!(width <= text_area_width);
+            lines.push(line);
+            widths.push(width);
+        }
+        (lines, widths)
+    }
+
+    #[test]
+    fn line_composer_one_line() {
+        let width = 40;
+        for i in 1..width {
+            let text = "a".repeat(i);
+            let (word_wrapper, _) =
+                run_composer(Composer::WordWrapper { trim: true }, &text, width as u16);
+            let (line_truncator, _) = run_composer(Composer::LineTruncator, &text, width as u16);
+            let expected = vec![text];
+            assert_eq!(word_wrapper, expected);
+            assert_eq!(line_truncator, expected);
+        }
+    }
+
+    #[test]
+    fn line_composer_short_lines() {
+        let width = 20;
+        let text =
+            "abcdefg\nhijklmno\npabcdefg\nhijklmn\nopabcdefghijk\nlmnopabcd\n\n\nefghijklmno";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+
+        let wrapped: Vec<&str> = text.split('\n').collect();
+        assert_eq!(word_wrapper, wrapped);
+        assert_eq!(line_truncator, wrapped);
+    }
+
+    #[test]
+    fn line_composer_long_word() {
+        let width = 20;
+        let text = "abcdefghijklmnopabcdefghijklmnopabcdefghijklmnopabcdefghijklmno";
+        let (word_wrapper, _) =
+            run_composer(Composer::WordWrapper { trim: true }, text, width as u16);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width as u16);
+
+        let wrapped = vec![
+            &text[..width],
+            &text[width..width * 2],
+            &text[width * 2..width * 3],
+            &text[width * 3..],
+        ];
+        assert_eq!(
+            word_wrapper, wrapped,
+            "WordWrapper should detect the line cannot be broken on word boundary and \
+             break it at line width limit."
+        );
+        assert_eq!(line_truncator, vec![&text[..width]]);
+    }
+
+    #[test]
+    fn line_composer_long_sentence() {
+        let width = 20;
+        let text =
+            "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab c d e f g h i j k l m n o";
+        let text_multi_space =
+            "abcd efghij    klmnopabcd efgh     ijklmnopabcdefg hijkl mnopab c d e f g h i j k l \
+             m n o";
+        let (word_wrapper_single_space, _) =
+            run_composer(Composer::WordWrapper { trim: true }, text, width as u16);
+        let (word_wrapper_multi_space, _) = run_composer(
+            Composer::WordWrapper { trim: true },
+            text_multi_space,
+            width as u16,
+        );
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width as u16);
+
+        let word_wrapped = vec![
+            "abcd efghij",
+            "klmnopabcd efgh",
+            "ijklmnopabcdefg",
+            "hijkl mnopab c d e f",
+            "g h i j k l m n o",
+        ];
+        assert_eq!(word_wrapper_single_space, word_wrapped);
+        assert_eq!(word_wrapper_multi_space, word_wrapped);
+
+        assert_eq!(line_truncator, vec![&text[..width]]);
+    }
+
+    #[test]
+    fn line_composer_zero_width() {
+        let width = 0;
+        let text = "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab ";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+
+        let expected: Vec<&str> = Vec::new();
+        assert_eq!(word_wrapper, expected);
+        assert_eq!(line_truncator, expected);
+    }
+
+    #[test]
+    fn line_composer_max_line_width_of_1() {
+        let width = 1;
+        let text = "abcd efghij klmnopabcd efgh ijklmnopabcdefg hijkl mnopab ";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+
+        let expected: Vec<&str> = UnicodeSegmentation::graphemes(text, true)
+            .filter(|g| g.chars().any(|c| !c.is_whitespace()))
+            .collect();
+        assert_eq!(word_wrapper, expected);
+        assert_eq!(line_truncator, vec!["a"]);
+    }
+
+    #[test]
+    fn line_composer_max_line_width_of_1_double_width_characters() {
+        let width = 1;
+        let text = "コンピュータ上で文字を扱う場合、典型的には文字\naaaによる通信を行う場合にその\
+                    両端点では、";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        assert_eq!(word_wrapper, vec!["", "a", "a", "a"]);
+        assert_eq!(line_truncator, vec!["", "a"]);
+    }
+
+    /// Tests WordWrapper with words some of which exceed line length and some not.
+    #[test]
+    fn line_composer_word_wrapper_mixed_length() {
+        let width = 20;
+        let text = "abcd efghij klmnopabcdefghijklmnopabcdefghijkl mnopab cdefghi j klmno";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        assert_eq!(
+            word_wrapper,
+            vec![
+                "abcd efghij",
+                "klmnopabcdefghijklmn",
+                "opabcdefghijkl",
+                "mnopab cdefghi j",
+                "klmno",
+            ]
+        )
+    }
+
+    #[test]
+    fn line_composer_double_width_chars() {
+        let width = 20;
+        let text = "コンピュータ上で文字を扱う場合、典型的には文字による通信を行う場合にその両端点\
+                    では、";
+        let (word_wrapper, word_wrapper_width) =
+            run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        assert_eq!(line_truncator, vec!["コンピュータ上で文字"]);
+        let wrapped = vec![
+            "コンピュータ上で文字",
+            "を扱う場合、典型的に",
+            "は文字による通信を行",
+            "う場合にその両端点で",
+            "は、",
+        ];
+        assert_eq!(word_wrapper, wrapped);
+        assert_eq!(word_wrapper_width, vec![width, width, width, width, 4]);
+    }
+
+    #[test]
+    fn line_composer_leading_whitespace_removal() {
+        let width = 20;
+        let text = "AAAAAAAAAAAAAAAAAAAA    AAA";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAAAAAAA", "AAA",]);
+        assert_eq!(line_truncator, vec!["AAAAAAAAAAAAAAAAAAAA"]);
+    }
+
+    /// Tests truncation of leading whitespace.
+    #[test]
+    fn line_composer_lots_of_spaces() {
+        let width = 20;
+        let text = "                                                                     ";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        assert_eq!(word_wrapper, vec![""]);
+        assert_eq!(line_truncator, vec!["                    "]);
+    }
+
+    /// Tests an input starting with a letter, followed by spaces - some of the behaviour is
+    /// incidental.
+    #[test]
+    fn line_composer_char_plus_lots_of_spaces() {
+        let width = 20;
+        let text = "a                                                                     ";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        let (line_truncator, _) = run_composer(Composer::LineTruncator, text, width);
+        // What's happening below is: the first line gets consumed, trailing spaces discarded,
+        // after 20 of which a word break occurs (probably shouldn't). The second line break
+        // discards all whitespace. The result should probably be vec!["a"] but it doesn't matter
+        // that much.
+        assert_eq!(word_wrapper, vec!["a", ""]);
+        assert_eq!(line_truncator, vec!["a                   "]);
+    }
+
+    #[test]
+    fn line_composer_word_wrapper_double_width_chars_mixed_with_spaces() {
+        let width = 20;
+        // Japanese seems not to use spaces but we should break on spaces anyway... We're using it
+        // to test double-width chars.
+        // You are more than welcome to add word boundary detection based of alterations of
+        // hiragana and katakana...
+        // This happens to also be a test case for mixed width because regular spaces are single width.
+        let text = "コンピュ ータ上で文字を扱う場合、 典型的には文 字による 通信を行 う場合にその両端点では、";
+        let (word_wrapper, word_wrapper_width) =
+            run_composer(Composer::WordWrapper { trim: true }, text, width);
+        assert_eq!(
+            word_wrapper,
+            vec![
+                "コンピュ",
+                "ータ上で文字を扱う場",
+                "合、 典型的には文",
+                "字による 通信を行",
+                "う場合にその両端点で",
+                "は、",
+            ]
+        );
+        // Odd-sized lines have a space in them.
+        assert_eq!(word_wrapper_width, vec![8, 20, 17, 17, 20, 4]);
+    }
+
+    /// Ensure words separated by nbsp are wrapped as if they were a single one.
+    #[test]
+    fn line_composer_word_wrapper_nbsp() {
+        let width = 20;
+        let text = "AAAAAAAAAAAAAAA AAAA\u{00a0}AAA";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: true }, text, width);
+        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAA", "AAAA\u{00a0}AAA",]);
+
+        // Ensure that if the character was a regular space, it would be wrapped differently.
+        let text_space = text.replace('\u{00a0}', " ");
+        let (word_wrapper_space, _) =
+            run_composer(Composer::WordWrapper { trim: true }, &text_space, width);
+        assert_eq!(word_wrapper_space, vec!["AAAAAAAAAAAAAAA AAAA", "AAA",]);
+    }
+
+    #[test]
+    fn line_composer_word_wrapper_preserve_indentation() {
+        let width = 20;
+        let text = "AAAAAAAAAAAAAAAAAAAA    AAA";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        assert_eq!(word_wrapper, vec!["AAAAAAAAAAAAAAAAAAAA", "   AAA",]);
+    }
+
+    #[test]
+    fn line_composer_word_wrapper_preserve_indentation_with_wrap() {
+        let width = 10;
+        let text = "AAA AAA AAAAA AA AAAAAA\n B\n  C\n   D";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        assert_eq!(
+            word_wrapper,
+            vec!["AAA AAA", "AAAAA AA", "AAAAAA", " B", "  C", "   D"]
+        );
+    }
+
+    #[test]
+    fn line_composer_word_wrapper_preserve_indentation_lots_of_whitespace() {
+        let width = 10;
+        let text = "               4 Indent\n                 must wrap!";
+        let (word_wrapper, _) = run_composer(Composer::WordWrapper { trim: false }, text, width);
+        assert_eq!(
+            word_wrapper,
+            vec![
+                "          ",
+                "    4",
+                "Indent",
+                "          ",
+                "      must",
+                "wrap!"
+            ]
+        );
+    }
+}
diff --git a/src/ratatui/widgets/sparkline.rs b/src/ratatui/widgets/sparkline.rs
new file mode 100644
index 00000000..a05df112
--- /dev/null
+++ b/src/ratatui/widgets/sparkline.rs
@@ -0,0 +1,155 @@
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols,
+    widgets::{Block, Widget},
+};
+use std::cmp::min;
+
+/// Widget to render a sparkline over one or more lines.
+///
+/// # Examples
+///
+/// ```
+/// # use ratatui::widgets::{Block, Borders, Sparkline};
+/// # use ratatui::style::{Style, Color};
+/// Sparkline::default()
+///     .block(Block::default().title("Sparkline").borders(Borders::ALL))
+///     .data(&[0, 2, 3, 4, 1, 4, 10])
+///     .max(5)
+///     .style(Style::default().fg(Color::Red).bg(Color::White));
+/// ```
+#[derive(Debug, Clone)]
+pub struct Sparkline<'a> {
+    /// A block to wrap the widget in
+    block: Option<Block<'a>>,
+    /// Widget style
+    style: Style,
+    /// A slice of the data to display
+    data: &'a [u64],
+    /// The maximum value to take to compute the maximum bar height (if nothing is specified, the
+    /// widget uses the max of the dataset)
+    max: Option<u64>,
+    /// A set of bar symbols used to represent the give data
+    bar_set: symbols::bar::Set,
+}
+
+impl<'a> Default for Sparkline<'a> {
+    fn default() -> Sparkline<'a> {
+        Sparkline {
+            block: None,
+            style: Default::default(),
+            data: &[],
+            max: None,
+            bar_set: symbols::bar::NINE_LEVELS,
+        }
+    }
+}
+
+impl<'a> Sparkline<'a> {
+    pub fn block(mut self, block: Block<'a>) -> Sparkline<'a> {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Sparkline<'a> {
+        self.style = style;
+        self
+    }
+
+    pub fn data(mut self, data: &'a [u64]) -> Sparkline<'a> {
+        self.data = data;
+        self
+    }
+
+    pub fn max(mut self, max: u64) -> Sparkline<'a> {
+        self.max = Some(max);
+        self
+    }
+
+    pub fn bar_set(mut self, bar_set: symbols::bar::Set) -> Sparkline<'a> {
+        self.bar_set = bar_set;
+        self
+    }
+}
+
+impl<'a> Widget for Sparkline<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        let spark_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        if spark_area.height < 1 {
+            return;
+        }
+
+        let max = match self.max {
+            Some(v) => v,
+            None => *self.data.iter().max().unwrap_or(&1u64),
+        };
+        let max_index = min(spark_area.width as usize, self.data.len());
+        let mut data = self
+            .data
+            .iter()
+            .take(max_index)
+            .map(|e| {
+                if max != 0 {
+                    e * u64::from(spark_area.height) * 8 / max
+                } else {
+                    0
+                }
+            })
+            .collect::<Vec<u64>>();
+        for j in (0..spark_area.height).rev() {
+            for (i, d) in data.iter_mut().enumerate() {
+                let symbol = match *d {
+                    0 => self.bar_set.empty,
+                    1 => self.bar_set.one_eighth,
+                    2 => self.bar_set.one_quarter,
+                    3 => self.bar_set.three_eighths,
+                    4 => self.bar_set.half,
+                    5 => self.bar_set.five_eighths,
+                    6 => self.bar_set.three_quarters,
+                    7 => self.bar_set.seven_eighths,
+                    _ => self.bar_set.full,
+                };
+                buf.get_mut(spark_area.left() + i as u16, spark_area.top() + j)
+                    .set_symbol(symbol)
+                    .set_style(self.style);
+
+                if *d > 8 {
+                    *d -= 8;
+                } else {
+                    *d = 0;
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn it_does_not_panic_if_max_is_zero() {
+        let widget = Sparkline::default().data(&[0, 0, 0]);
+        let area = Rect::new(0, 0, 3, 1);
+        let mut buffer = Buffer::empty(area);
+        widget.render(area, &mut buffer);
+    }
+
+    #[test]
+    fn it_does_not_panic_if_max_is_set_to_zero() {
+        let widget = Sparkline::default().data(&[0, 1, 2]).max(0);
+        let area = Rect::new(0, 0, 3, 1);
+        let mut buffer = Buffer::empty(area);
+        widget.render(area, &mut buffer);
+    }
+}
diff --git a/src/ratatui/widgets/table.rs b/src/ratatui/widgets/table.rs
new file mode 100644
index 00000000..d987a8d9
--- /dev/null
+++ b/src/ratatui/widgets/table.rs
@@ -0,0 +1,504 @@
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::{Constraint, Direction, Layout, Rect},
+    style::Style,
+    text::Text,
+    widgets::{Block, StatefulWidget, Widget},
+};
+use unicode_width::UnicodeWidthStr;
+
+/// A [`Cell`] contains the [`Text`] to be displayed in a [`Row`] of a [`Table`].
+///
+/// It can be created from anything that can be converted to a [`Text`].
+/// ```rust
+/// # use ratatui::widgets::Cell;
+/// # use ratatui::style::{Style, Modifier};
+/// # use ratatui::text::{Span, Spans, Text};
+/// # use std::borrow::Cow;
+/// Cell::from("simple string");
+///
+/// Cell::from(Span::from("span"));
+///
+/// Cell::from(Spans::from(vec![
+///     Span::raw("a vec of "),
+///     Span::styled("spans", Style::default().add_modifier(Modifier::BOLD))
+/// ]));
+///
+/// Cell::from(Text::from("a text"));
+///
+/// Cell::from(Text::from(Cow::Borrowed("hello")));
+/// ```
+///
+/// You can apply a [`Style`] on the entire [`Cell`] using [`Cell::style`] or rely on the styling
+/// capabilities of [`Text`].
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct Cell<'a> {
+    content: Text<'a>,
+    style: Style,
+}
+
+impl<'a> Cell<'a> {
+    /// Set the `Style` of this cell.
+    pub fn style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+}
+
+impl<'a, T> From<T> for Cell<'a>
+where
+    T: Into<Text<'a>>,
+{
+    fn from(content: T) -> Cell<'a> {
+        Cell {
+            content: content.into(),
+            style: Style::default(),
+        }
+    }
+}
+
+/// Holds data to be displayed in a [`Table`] widget.
+///
+/// A [`Row`] is a collection of cells. It can be created from simple strings:
+/// ```rust
+/// # use ratatui::widgets::Row;
+/// Row::new(vec!["Cell1", "Cell2", "Cell3"]);
+/// ```
+///
+/// But if you need a bit more control over individual cells, you can explicitly create [`Cell`]s:
+/// ```rust
+/// # use ratatui::widgets::{Row, Cell};
+/// # use ratatui::style::{Style, Color};
+/// Row::new(vec![
+///     Cell::from("Cell1"),
+///     Cell::from("Cell2").style(Style::default().fg(Color::Yellow)),
+/// ]);
+/// ```
+///
+/// You can also construct a row from any type that can be converted into [`Text`]:
+/// ```rust
+/// # use std::borrow::Cow;
+/// # use ratatui::widgets::Row;
+/// Row::new(vec![
+///     Cow::Borrowed("hello"),
+///     Cow::Owned("world".to_uppercase()),
+/// ]);
+/// ```
+///
+/// By default, a row has a height of 1 but you can change this using [`Row::height`].
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct Row<'a> {
+    cells: Vec<Cell<'a>>,
+    height: u16,
+    style: Style,
+    bottom_margin: u16,
+}
+
+impl<'a> Row<'a> {
+    /// Creates a new [`Row`] from an iterator where items can be converted to a [`Cell`].
+    pub fn new<T>(cells: T) -> Self
+    where
+        T: IntoIterator,
+        T::Item: Into<Cell<'a>>,
+    {
+        Self {
+            height: 1,
+            cells: cells.into_iter().map(|c| c.into()).collect(),
+            style: Style::default(),
+            bottom_margin: 0,
+        }
+    }
+
+    /// Set the fixed height of the [`Row`]. Any [`Cell`] whose content has more lines than this
+    /// height will see its content truncated.
+    pub fn height(mut self, height: u16) -> Self {
+        self.height = height;
+        self
+    }
+
+    /// Set the [`Style`] of the entire row. This [`Style`] can be overridden by the [`Style`] of a
+    /// any individual [`Cell`] or event by their [`Text`] content.
+    pub fn style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+
+    /// Set the bottom margin. By default, the bottom margin is `0`.
+    pub fn bottom_margin(mut self, margin: u16) -> Self {
+        self.bottom_margin = margin;
+        self
+    }
+
+    /// Returns the total height of the row.
+    fn total_height(&self) -> u16 {
+        self.height.saturating_add(self.bottom_margin)
+    }
+}
+
+/// A widget to display data in formatted columns.
+///
+/// It is a collection of [`Row`]s, themselves composed of [`Cell`]s:
+/// ```rust
+/// # use ratatui::widgets::{Block, Borders, Table, Row, Cell};
+/// # use ratatui::layout::Constraint;
+/// # use ratatui::style::{Style, Color, Modifier};
+/// # use ratatui::text::{Text, Spans, Span};
+/// Table::new(vec![
+///     // Row can be created from simple strings.
+///     Row::new(vec!["Row11", "Row12", "Row13"]),
+///     // You can style the entire row.
+///     Row::new(vec!["Row21", "Row22", "Row23"]).style(Style::default().fg(Color::Blue)),
+///     // If you need more control over the styling you may need to create Cells directly
+///     Row::new(vec![
+///         Cell::from("Row31"),
+///         Cell::from("Row32").style(Style::default().fg(Color::Yellow)),
+///         Cell::from(Spans::from(vec![
+///             Span::raw("Row"),
+///             Span::styled("33", Style::default().fg(Color::Green))
+///         ])),
+///     ]),
+///     // If a Row need to display some content over multiple lines, you just have to change
+///     // its height.
+///     Row::new(vec![
+///         Cell::from("Row\n41"),
+///         Cell::from("Row\n42"),
+///         Cell::from("Row\n43"),
+///     ]).height(2),
+/// ])
+/// // You can set the style of the entire Table.
+/// .style(Style::default().fg(Color::White))
+/// // It has an optional header, which is simply a Row always visible at the top.
+/// .header(
+///     Row::new(vec!["Col1", "Col2", "Col3"])
+///         .style(Style::default().fg(Color::Yellow))
+///         // If you want some space between the header and the rest of the rows, you can always
+///         // specify some margin at the bottom.
+///         .bottom_margin(1)
+/// )
+/// // As any other widget, a Table can be wrapped in a Block.
+/// .block(Block::default().title("Table"))
+/// // Columns widths are constrained in the same way as Layout...
+/// .widths(&[Constraint::Length(5), Constraint::Length(5), Constraint::Length(10)])
+/// // ...and they can be separated by a fixed spacing.
+/// .column_spacing(1)
+/// // If you wish to highlight a row in any specific way when it is selected...
+/// .highlight_style(Style::default().add_modifier(Modifier::BOLD))
+/// // ...and potentially show a symbol in front of the selection.
+/// .highlight_symbol(">>");
+/// ```
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Table<'a> {
+    /// A block to wrap the widget in
+    block: Option<Block<'a>>,
+    /// Base style for the widget
+    style: Style,
+    /// Width constraints for each column
+    widths: &'a [Constraint],
+    /// Space between each column
+    column_spacing: u16,
+    /// Style used to render the selected row
+    highlight_style: Style,
+    /// Symbol in front of the selected rom
+    highlight_symbol: Option<&'a str>,
+    /// Optional header
+    header: Option<Row<'a>>,
+    /// Data to display in each row
+    rows: Vec<Row<'a>>,
+}
+
+impl<'a> Table<'a> {
+    pub fn new<T>(rows: T) -> Self
+    where
+        T: IntoIterator<Item = Row<'a>>,
+    {
+        Self {
+            block: None,
+            style: Style::default(),
+            widths: &[],
+            column_spacing: 1,
+            highlight_style: Style::default(),
+            highlight_symbol: None,
+            header: None,
+            rows: rows.into_iter().collect(),
+        }
+    }
+
+    pub fn block(mut self, block: Block<'a>) -> Self {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn header(mut self, header: Row<'a>) -> Self {
+        self.header = Some(header);
+        self
+    }
+
+    pub fn widths(mut self, widths: &'a [Constraint]) -> Self {
+        let between_0_and_100 = |&w| match w {
+            Constraint::Percentage(p) => p <= 100,
+            _ => true,
+        };
+        assert!(
+            widths.iter().all(between_0_and_100),
+            "Percentages should be between 0 and 100 inclusively."
+        );
+        self.widths = widths;
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Self {
+        self.style = style;
+        self
+    }
+
+    pub fn highlight_symbol(mut self, highlight_symbol: &'a str) -> Self {
+        self.highlight_symbol = Some(highlight_symbol);
+        self
+    }
+
+    pub fn highlight_style(mut self, highlight_style: Style) -> Self {
+        self.highlight_style = highlight_style;
+        self
+    }
+
+    pub fn column_spacing(mut self, spacing: u16) -> Self {
+        self.column_spacing = spacing;
+        self
+    }
+
+    fn get_columns_widths(&self, max_width: u16, has_selection: bool) -> Vec<u16> {
+        let mut constraints = Vec::with_capacity(self.widths.len() * 2 + 1);
+        if has_selection {
+            let highlight_symbol_width =
+                self.highlight_symbol.map(|s| s.width() as u16).unwrap_or(0);
+            constraints.push(Constraint::Length(highlight_symbol_width));
+        }
+        for constraint in self.widths {
+            constraints.push(*constraint);
+            constraints.push(Constraint::Length(self.column_spacing));
+        }
+        if !self.widths.is_empty() {
+            constraints.pop();
+        }
+        let chunks = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints(constraints)
+            .expand_to_fill(false)
+            .split(Rect {
+                x: 0,
+                y: 0,
+                width: max_width,
+                height: 1,
+            });
+        let mut chunks = &chunks[..];
+        if has_selection {
+            chunks = &chunks[1..];
+        }
+        chunks.iter().step_by(2).map(|c| c.width).collect()
+    }
+
+    fn get_row_bounds(
+        &self,
+        selected: Option<usize>,
+        offset: usize,
+        max_height: u16,
+    ) -> (usize, usize) {
+        let offset = offset.min(self.rows.len().saturating_sub(1));
+        let mut start = offset;
+        let mut end = offset;
+        let mut height = 0;
+        for item in self.rows.iter().skip(offset) {
+            if height + item.height > max_height {
+                break;
+            }
+            height += item.total_height();
+            end += 1;
+        }
+
+        let selected = selected.unwrap_or(0).min(self.rows.len() - 1);
+        while selected >= end {
+            height = height.saturating_add(self.rows[end].total_height());
+            end += 1;
+            while height > max_height {
+                height = height.saturating_sub(self.rows[start].total_height());
+                start += 1;
+            }
+        }
+        while selected < start {
+            start -= 1;
+            height = height.saturating_add(self.rows[start].total_height());
+            while height > max_height {
+                end -= 1;
+                height = height.saturating_sub(self.rows[end].total_height());
+            }
+        }
+        (start, end)
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct TableState {
+    offset: usize,
+    selected: Option<usize>,
+}
+
+impl TableState {
+    pub fn selected(&self) -> Option<usize> {
+        self.selected
+    }
+
+    pub fn select(&mut self, index: Option<usize>) {
+        self.selected = index;
+        if index.is_none() {
+            self.offset = 0;
+        }
+    }
+
+    /// Returns a copy of the receiver's scroll offset.
+    ///
+    /// This is useful, for example, if you need to "synchronize" the scrolling of a `Table` and a `Paragraph`.
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+}
+
+impl<'a> StatefulWidget for Table<'a> {
+    type State = TableState;
+
+    fn render(mut self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
+        if area.area() == 0 {
+            return;
+        }
+        buf.set_style(area, self.style);
+        let table_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        let has_selection = state.selected.is_some();
+        let columns_widths = self.get_columns_widths(table_area.width, has_selection);
+        let highlight_symbol = self.highlight_symbol.unwrap_or("");
+        let blank_symbol = " ".repeat(highlight_symbol.width());
+        let mut current_height = 0;
+        let mut rows_height = table_area.height;
+
+        // Draw header
+        if let Some(ref header) = self.header {
+            let max_header_height = table_area.height.min(header.total_height());
+            buf.set_style(
+                Rect {
+                    x: table_area.left(),
+                    y: table_area.top(),
+                    width: table_area.width,
+                    height: table_area.height.min(header.height),
+                },
+                header.style,
+            );
+            let mut col = table_area.left();
+            if has_selection {
+                col += (highlight_symbol.width() as u16).min(table_area.width);
+            }
+            for (width, cell) in columns_widths.iter().zip(header.cells.iter()) {
+                render_cell(
+                    buf,
+                    cell,
+                    Rect {
+                        x: col,
+                        y: table_area.top(),
+                        width: *width,
+                        height: max_header_height,
+                    },
+                );
+                col += *width + self.column_spacing;
+            }
+            current_height += max_header_height;
+            rows_height = rows_height.saturating_sub(max_header_height);
+        }
+
+        // Draw rows
+        if self.rows.is_empty() {
+            return;
+        }
+        let (start, end) = self.get_row_bounds(state.selected, state.offset, rows_height);
+        state.offset = start;
+        for (i, table_row) in self
+            .rows
+            .iter_mut()
+            .enumerate()
+            .skip(state.offset)
+            .take(end - start)
+        {
+            let (row, col) = (table_area.top() + current_height, table_area.left());
+            current_height += table_row.total_height();
+            let table_row_area = Rect {
+                x: col,
+                y: row,
+                width: table_area.width,
+                height: table_row.height,
+            };
+            buf.set_style(table_row_area, table_row.style);
+            let is_selected = state.selected.map(|s| s == i).unwrap_or(false);
+            let table_row_start_col = if has_selection {
+                let symbol = if is_selected {
+                    highlight_symbol
+                } else {
+                    &blank_symbol
+                };
+                let (col, _) =
+                    buf.set_stringn(col, row, symbol, table_area.width as usize, table_row.style);
+                col
+            } else {
+                col
+            };
+            let mut col = table_row_start_col;
+            for (width, cell) in columns_widths.iter().zip(table_row.cells.iter()) {
+                render_cell(
+                    buf,
+                    cell,
+                    Rect {
+                        x: col,
+                        y: row,
+                        width: *width,
+                        height: table_row.height,
+                    },
+                );
+                col += *width + self.column_spacing;
+            }
+            if is_selected {
+                buf.set_style(table_row_area, self.highlight_style);
+            }
+        }
+    }
+}
+
+fn render_cell(buf: &mut Buffer, cell: &Cell, area: Rect) {
+    buf.set_style(area, cell.style);
+    for (i, spans) in cell.content.lines.iter().enumerate() {
+        if i as u16 >= area.height {
+            break;
+        }
+        buf.set_spans(area.x, area.y + i as u16, spans, area.width);
+    }
+}
+
+impl<'a> Widget for Table<'a> {
+    fn render(self, area: Rect, buf: &mut Buffer) {
+        let mut state = TableState::default();
+        StatefulWidget::render(self, area, buf, &mut state);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn table_invalid_percentages() {
+        Table::new(vec![]).widths(&[Constraint::Percentage(110)]);
+    }
+}
diff --git a/src/ratatui/widgets/tabs.rs b/src/ratatui/widgets/tabs.rs
new file mode 100644
index 00000000..9b5f5469
--- /dev/null
+++ b/src/ratatui/widgets/tabs.rs
@@ -0,0 +1,129 @@
+use crate::ratatui::{
+    buffer::Buffer,
+    layout::Rect,
+    style::Style,
+    symbols,
+    text::{Span, Spans},
+    widgets::{Block, Widget},
+};
+
+/// A widget to display available tabs in a multiple panels context.
+///
+/// # Examples
+///
+/// ```
+/// # use ratatui::widgets::{Block, Borders, Tabs};
+/// # use ratatui::style::{Style, Color};
+/// # use ratatui::text::{Spans};
+/// # use ratatui::symbols::{DOT};
+/// let titles = ["Tab1", "Tab2", "Tab3", "Tab4"].iter().cloned().map(Spans::from).collect();
+/// Tabs::new(titles)
+///     .block(Block::default().title("Tabs").borders(Borders::ALL))
+///     .style(Style::default().fg(Color::White))
+///     .highlight_style(Style::default().fg(Color::Yellow))
+///     .divider(DOT);
+/// ```
+#[derive(Debug, Clone)]
+pub struct Tabs<'a> {
+    /// A block to wrap this widget in if necessary
+    block: Option<Block<'a>>,
+    /// One title for each tab
+    titles: Vec<Spans<'a>>,
+    /// The index of the selected tabs
+    selected: usize,
+    /// The style used to draw the text
+    style: Style,
+    /// Style to apply to the selected item
+    highlight_style: Style,
+    /// Tab divider
+    divider: Span<'a>,
+}
+
+impl<'a> Tabs<'a> {
+    pub fn new(titles: Vec<Spans<'a>>) -> Tabs<'a> {
+        Tabs {
+            block: None,
+            titles,
+            selected: 0,
+            style: Default::default(),
+            highlight_style: Default::default(),
+            divider: Span::raw(symbols::line::VERTICAL),
+        }
+    }
+
+    pub fn block(mut self, block: Block<'a>) -> Tabs<'a> {
+        self.block = Some(block);
+        self
+    }
+
+    pub fn select(mut self, selected: usize) -> Tabs<'a> {
+        self.selected = selected;
+        self
+    }
+
+    pub fn style(mut self, style: Style) -> Tabs<'a> {
+        self.style = style;
+        self
+    }
+
+    pub fn highlight_style(mut self, style: Style) -> Tabs<'a> {
+        self.highlight_style = style;
+        self
+    }
+
+    pub fn divider<T>(mut self, divider: T) -> Tabs<'a>
+    where
+        T: Into<Span<'a>>,
+    {
+        self.divider = divider.into();
+        self
+    }
+}
+
+impl<'a> Widget for Tabs<'a> {
+    fn render(mut self, area: Rect, buf: &mut Buffer) {
+        buf.set_style(area, self.style);
+        let tabs_area = match self.block.take() {
+            Some(b) => {
+                let inner_area = b.inner(area);
+                b.render(area, buf);
+                inner_area
+            }
+            None => area,
+        };
+
+        if tabs_area.height < 1 {
+            return;
+        }
+
+        let mut x = tabs_area.left();
+        let titles_length = self.titles.len();
+        for (i, title) in self.titles.into_iter().enumerate() {
+            let last_title = titles_length - 1 == i;
+            x = x.saturating_add(1);
+            let remaining_width = tabs_area.right().saturating_sub(x);
+            if remaining_width == 0 {
+                break;
+            }
+            let pos = buf.set_spans(x, tabs_area.top(), &title, remaining_width);
+            if i == self.selected {
+                buf.set_style(
+                    Rect {
+                        x,
+                        y: tabs_area.top(),
+                        width: pos.0.saturating_sub(x),
+                        height: 1,
+                    },
+                    self.highlight_style,
+                );
+            }
+            x = pos.0.saturating_add(1);
+            let remaining_width = tabs_area.right().saturating_sub(x);
+            if remaining_width == 0 || last_title {
+                break;
+            }
+            let pos = buf.set_span(x, tabs_area.top(), &self.divider, remaining_width);
+            x = pos.0;
+        }
+    }
+}