hirohig_palindrome 0.1.0

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/NOTICE.md

@@ -0,0 +1,170 @@
+# COPYRIGHT NOTICES
+
+## ANSI
+
+Copyright © 2009 [Rubyworks](http://rubyworks.github.com) ·
+License [BSD-2-Clause](http://spdx.org/licenses/BSD-2-Clause) ·
+Website http://rubyworks.github.com/ansi
+
+    Copyright 2009 Rubyworks.
+
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without modification, are
+    permitted provided that the following conditions are met:
+
+       1. Redistributions of source code must retain the above copyright notice, this list of
+          conditions and the following disclaimer.
+
+       2. Redistributions in binary form must reproduce the above copyright notice, this list
+          of conditions and the following disclaimer in the documentation and/or other materials
+          provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESS OR IMPLIED
+    WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS
+    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+    CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+    ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+    ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+    (https://raw.github.com/rubyworks/ansi/master/LICENSE.txt)
+
+
+## ProgressBar
+
+Copyright © 2001 *Satoru Takabayashi* ·
+License [Ruby](http://spdx.org/licenses/Ruby) ·
+Website http://0xcc.net/ruby-progressbar
+
+ProgressBar class is based on the original ProgressBar by Satoru Takabayashi.
+
+    Ruby/ProgressBar - a text progress bar library
+
+    Copyright (C) 2001-2005 Satoru Takabayashi <satoru@namazu.org>
+        All rights reserved.
+        This is free software with ABSOLUTELY NO WARRANTY.
+
+    You can redistribute it and/or modify it under the terms
+    of Ruby's license.
+
+
+## HighLine (Terminal Extensions)
+
+Copyright &copy; 2006 *Gray Productions* &middot;
+License [Ruby](http://spdx.org/licenses/Ruby) &middot;
+Website http://highline.rubyforge.org
+
+The terminal extensions are based on HighLine's SystemExtensions
+by James Edward Gray II.
+
+    Copyright 2006 Gray Productions
+
+    Distributed under the user's choice of the {GPL Version 2}[http://www.gnu.org/licenses/old-licenses/gpl-2.0.html]
+    (see GPL-2.0.txt for details) or the {Ruby software license}[http://www.ruby-lang.org/en/LICENSE.txt]
+    by James Edward Gray II and Greg Brown.
+
+    Please email James[mailto:james@grayproductions.net] with any questions.
+
+    (https://github.com/JEG2/highline/blob/master/LICENSE)
+
+
+## BBCode
+
+Copyright &copy; 2002 *Thomas-Ivo Heinen* &middot;
+License [Ruby](http://spdx.org/licenses/Ruby)
+
+BBCode module is a derivative of BBCode by Thomas-Ivo Heinen.
+
+    Copyright (c) 2002 Thomas-Ivo Heinen
+
+    This module is free software. You may use, modify, and/or redistribute this
+    software under the same terms as Ruby.
+
+    This program is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+    FOR A PARTICULAR PURPOSE.
+
+
+## Rainbow (XTerm Color Support)
+
+Copyright &copy; *Marcin Kulik* &middot;
+License [MIT](http://spdx.org/licenses/MIT) &middot;
+Website http://github.com/sickill/rainbow
+
+Rainbox provided the bases for building the XTerm 256 color code
+support into the ANSI::Code module.
+
+    Copyright (c) Marcin Kulik
+
+    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.
+
+    (https://raw.github.com/sickill/rainbow/master/LICENSE)
+
+
+## Paint (ANSI Code Names)
+
+Copyright &copy; 2011 *Jan Lelis* &middot;
+License [MIT](http://spdx.org/licenses/MIT) &middot;
+Website https://github.com/janlelis/paint
+
+Some of the latest ANSI code names, and inspiration to check out Rainbow
+and include XTerm 256 color codes, came from Paint.
+
+    Copyright (c) 2011 Jan Lelis
+
+    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.
+
+    (https://raw.github.com/janlelis/paint/master/LICENSE.txt)
+
+
+## ANSIColor
+
+_Acknowlegement_
+
+Copyright &copy; 2002 *Florian Frank* &middot;
+Website http://flori.github.com/term-ansicolor
+
+Albeit the code no long bares much, if any, resemblance to it, the ANSI Code
+module (and subsequently the Constants module) originated with the
+ANSIColor library by Florian Frank.
+
+    Copyright (c) 2002 Florian Frank
+
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/README.md

@@ -0,0 +1,91 @@
+# ANSI
+
+[HOME](http://rubyworks.github.com/ansi) ·
+[API](http://rubydoc.info/gems/ansi/frames) ·
+[MAIL](http://googlegroups.com/group/rubyworks-mailinglist)  ·
+[ISSUES](http://github.com/rubyworks/ansi/issues) ·
+[SOURCE](http://github.com/rubyworks/ansi)
+
+[![Build Status](https://secure.travis-ci.org/rubyworks/ansi.png)](http://travis-ci.org/rubyworks/ansi)
+
+<br/>
+
+The ANSI project is a collection of ANSI escape code related libraries
+enabling ANSI code based colorization and stylization of output.
+It is very nice for beautifying shell output.
+
+This collection is based on a set of scripts spun-off from
+Ruby Facets. Included are Code (used to be ANSICode), Logger,
+ProgressBar and String. In addition the library includes
+Terminal which provides information about the current output
+device.
+
+
+## Features
+
+* ANSI::Code provides ANSI codes as module functions.
+* String#ansi makes common usage very easy and elegant.
+* ANSI::Mixin provides an alternative mixin (like +colored+ gem).
+* Very Good coverage of standard ANSI codes.
+* Additional clases for colorized columns, tables, loggers and more.
+
+
+## Synopsis
+
+There are a number of modules and classes provided by the ANSI
+package. To get a good understanding of them it is best to pursue 
+the [QED documents](http://github.com/rubyworks/ansi/tree/master/qed/)
+or the [API documentation](http://rubyworks.github.com/ansi/api/index.html).
+
+At the heart of all the provided libraries lies the ANSI::Code module
+which defines ANSI codes as constants and methods. For example:
+
+    require 'ansi/code'
+
+    ANSI.red + "Hello" + ANSI.blue + "World"
+    => "\e[31mHello\e[34mWorld"
+
+Or in block form.
+
+    ANSI.red{ "Hello" } + ANSI.blue{ "World" }
+    => "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+The methods defined by this module are used throughout the rest of
+the system.
+
+
+## Installation
+
+### RubyGems
+
+To install with RubyGems simply open a console and type:
+
+    $ sudo gem install ansi
+
+### Setup.rb (not recommended)
+
+Local installation requires Setup.rb (gem install setup),
+then [download](http://github.com/rubyworks/ansi/download) the tarball package and type:
+
+    $ tar -xvzf ansi-1.0.0.tgz
+    $ cd ansi-1.0.0
+    $ sudo setup.rb all
+
+Windows users use 'ruby setup.rb all'.
+
+
+## Release Notes
+
+Please see HISTORY.md file.
+
+
+## License & Copyrights
+
+Copyright (c) 2009 Rubyworks
+
+This program is redistributable under the terms of the *FreeBSD* license.
+
+Some pieces of the code are copyrighted by others.
+
+See LICENSE.txt and NOTICE.md files for details.
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/01_ansicode.md

@@ -0,0 +1,65 @@
+# ANSI::Code
+
+Require the library.
+
+    require 'ansi/code'
+
+ANSI::Code can be used as a functions module.
+
+    str = ANSI::Code.red + "Hello" + ANSI::Code.blue + "World"
+    str.assert == "\e[31mHello\e[34mWorld"
+
+If a block is supplied to each method then yielded value will
+be wrapped in the ANSI code and clear code. 
+
+    str = ANSI::Code.red{ "Hello" } + ANSI::Code.blue{ "World" }
+    str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+More conveniently the ANSI::Code module extends ANSI itself.
+
+    str = ANSI.red + "Hello" + ANSI.blue + "World"
+    str.assert == "\e[31mHello\e[34mWorld"
+
+    str = ANSI.red{ "Hello" } + ANSI.blue{ "World" }
+    str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+ANSI also supports XTerm 256 color mode using red, blue and green values
+with the `#rgb` method.
+
+    str = ANSI::Code.rgb(0, 255, 0)
+    str.assert == "\e[38;5;46m"
+
+Or using CSS style hex codes as well.
+
+    str = ANSI::Code.rgb("#00FF00")
+    str.assert == "\e[38;5;46m"
+
+Both of these methods can take blocks to wrap text in the color and clear codes.
+
+    str = ANSI::Code.rgb("#00FF00"){ "Hello" }
+    str.assert == "\e[38;5;46mHello\e[0m"
+
+In the appropriate context the ANSI::Code module can also be
+included, making its methods directly accessible.
+
+    include ANSI::Code
+
+    str = red + "Hello" + blue + "World"
+    str.assert == "\e[31mHello\e[34mWorld"
+
+    str = red{ "Hello" } + blue{ "World" }
+    str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+
+Along with the single font colors, the library include background colors.
+
+    str = on_red + "Hello"
+    str.assert == "\e[41mHello"
+
+As well as combined color methods.
+
+    str = white_on_red + "Hello"
+    str.assert == "\e[37m\e[41mHello"
+
+The ANSI::Code module supports most standard ANSI codes, though
+not all platforms support every code, so YMMV.
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/02_core.md

@@ -0,0 +1,11 @@
+# String Extensions
+
+In addition the library offers an extension to String class
+called #ansi, which allows some of the ANSI::Code methods
+to be called in a more object-oriented fashion.
+
+    require 'ansi/core'
+
+    str = "Hello".ansi(:red) + "World".ansi(:blue)
+    str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m"
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/03_logger.md

@@ -0,0 +1,30 @@
+# ANSI::Logger
+
+Require the ANSI::Logger library.
+
+    require 'ansi/logger'
+
+Create a new ANSI::Logger
+
+    log = ANSI::Logger.new(STDOUT)
+
+Info logging appears normal.
+
+    log.info{"Info logs are green.\n"}
+
+Warn logging appears yellow.
+
+    log.warn{"Warn logs are yellow.\n"}
+
+Debug logging appears cyan.
+
+    log.debug{"Debug logs are cyan.\n"}
+
+Error logging appears red.
+
+    log.error{"Error logs are red.\n"}
+
+Fatal logging appears bright red.
+
+    log.fatal{"Fatal logs are bold red!\n"}
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/04_progressbar.md

@@ -0,0 +1,62 @@
+# ANSI::Progressbar
+
+Pretty progress bars are easy to construct.
+
+    require 'ansi/progressbar'
+
+    pbar = ANSI::Progressbar.new("Test Bar", 100)
+
+Running the bar simply requires calling the #inc method during
+a loop and calling `#finish` when done.
+
+    100.times do |i|
+      sleep 0.01
+      pbar.inc
+    end
+    pbar.finish
+
+We will use this same rountine in all the examples below, so lets
+make a quick macro for it. Notice we have to use `#reset` first
+before reusing the same progress bar.
+
+    def run(pbar)
+      pbar.reset
+      100.times do |i|
+        sleep 0.01
+        pbar.inc
+      end
+      pbar.finish
+      puts
+    end
+
+The progress bar can be stylized in almost any way.
+The `#format` setter provides control over the parts
+that appear on the line. For example, by default the
+format is:
+
+    pbar.format("%-14s %3d%% %s %s", :title, :percentage, :bar, :stat)
+
+So lets vary it up to demonstrate the case.
+
+    pbar.format("%-14s %3d%% %s %s", :title, :percentage, :stat, :bar)
+    run(pbar)
+
+The progress bar has an extra build in format intended for use with
+file downloads called `#transer_mode`.
+
+    pbar.transfer_mode
+    run(pbar)
+
+Calling this methods is the same as calling:
+
+    pbar.format("%-14s %3d%% %s %s",:title, :percentage, :bar, :stat_for_file_transfer)
+    run(pbar)
+
+The `#style` setter allows each part of the line be modified with ANSI codes. And the
+`#bar_mark` writer can be used to change the character used to make the bar.
+
+    pbar.standard_mode
+    pbar.style(:title => [:red], :bar=>[:blue])
+    pbar.bar_mark = "="
+    run(pbar)
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/05_mixin.md

@@ -0,0 +1,37 @@
+# ANSI::Mixin
+
+The ANSI::Mixin module is design for including into
+String-like classes. It will support any class that defines
+a #to_s method.
+
+    require 'ansi/mixin'
+
+In this demonstration we will simply include it in the
+core String class.
+
+    class ::String
+      include ANSI::Mixin
+    end
+
+Now all strings will have access to ANSI's style and color
+codes via simple method calls.
+
+    "roses".red.assert == "\e[31mroses\e[0m"
+
+    "violets".blue.assert == "\e[34mviolets\e[0m"
+
+    "sugar".italic.assert == "\e[3msugar\e[0m"
+
+The method can be combined, of course.
+
+    "you".italic.bold.assert == "\e[1m\e[3myou\e[0m\e[0m"
+
+The mixin also supports background methods.
+
+    "envy".on_green.assert == "\e[42menvy\e[0m"
+
+And it also supports the combined foreground-on-background 
+methods.
+
+    "b&w".white_on_black.assert == "\e[37m\e[40mb&w\e[0m"
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/06_string.md

@@ -0,0 +1,56 @@
+# ANSI::String
+
+The ANSI::String class is a very sophisticated implementation
+of Ruby's standard String class, but one that can handle
+ANSI codes seamlessly.
+
+    require 'ansi/string'
+
+    flower1 = ANSI::String.new("Roses")
+    flower2 = ANSI::String.new("Violets")
+
+Like any other string.
+
+    flower1.to_s.assert == "Roses"
+    flower2.to_s.assert == "Violets"
+
+Bet now we can add color.
+
+    flower1.red!
+    flower2.blue!
+
+    flower1.to_s.assert == "\e[31mRoses\e[0m"
+    flower2.to_s.assert == "\e[34mViolets\e[0m"
+
+Despite that the string representation now contains ANSI codes,
+we can still manipulate the string in much the same way that
+we manipulate an ordinary string.
+
+    flower1.size.assert == 5
+    flower2.size.assert == 7
+
+Like ordinary strings we can concatenate the two strings
+
+    flowers = flower1 + ' ' + flower2
+    flowers.to_s.assert == "\e[31mRoses\e[0m \e[34mViolets\e[0m"
+
+    flowers.size.assert == 13
+
+Standard case conversion such as #upcase and #downcase work.
+
+    flower1.upcase.to_s.assert == "\e[31mROSES\e[0m"
+    flower1.downcase.to_s.assert == "\e[31mroses\e[0m"
+
+Some of the most difficult methods to re-implement were the 
+substitution methods such as #sub and #gsub. They are still
+somewhat more limited than the original string methods, but
+their primary functionality should work.
+
+    flower1.gsub('s', 'z').to_s.assert == "\e[31mRozez\e[0m"
+
+There are still a number of methods that need implementation.
+ANSI::String is currently a very partial implementation. But
+as you can see from the methods it does currently support,
+is it already useful.
+
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/07_columns.md

@@ -0,0 +1,89 @@
+# ANSI::Columns
+
+The +Columns+ class makes it easy to create nice looking text columns,
+sorted from top to bottom, right to left (as opposed to the other way
+around).
+
+    require 'ansi/columns'
+
+    list = %w{a b c d e f g h i j k l}
+
+    columns = ANSI::Columns.new(list)
+
+    columns.to_s(4)
+
+The output will be:
+
+    a d g j
+    b e h k
+    c f i l
+
+Besides an array of elements, Columns.new can take a string in which
+the elements are divided by newlines characters. The default column
+size can also be given to the initializer.
+
+    list = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl"
+
+    columns = ANSI::Columns.new(list, :columns=>6)
+
+    columns.to_s
+
+The output will be:
+
+    a c e g i k
+    b d f h j l
+
+If the column count is +nil+, then the number of columns will be calculated
+as a best fit for the current terminal window.
+
+## Padding
+
+Columns can adjust the padding between cells.
+
+    list = %w{a b c d e f g h i j k l}
+
+    columns = ANSI::Columns.new(list, :padding=>2)
+
+    columns.to_s(4)
+
+The output will be:
+
+    a  d  g  j
+    b  e  h  k
+    c  f  i  l
+
+## Alignment
+
+Columns can also be aligned either left or right.
+
+    list = %w{xx xx xx yy y yy z zz z}
+
+    columns = ANSI::Columns.new(list, :align=>:right)
+
+    columns.to_s(3)
+
+The output will be:
+
+    xx yy  z
+    xx  y zz
+    xx yy  z
+
+## Format
+
+Lastly, columns can be augmented with ANSI codes. This is done through
+a formatting block. The block can take up to three parameters, the cell
+content, the column and row numbers, or the cell and the column and row
+numbers.
+
+    list = %w{a b c d e f g h i j k l}
+
+    columns = ANSI::Columns.new(list){ |c,r| r % 2 == 0 ? :red : :blue }
+
+    out = columns.to_s(4)
+
+    out.assert == (
+      "\e[31ma \e[0m\e[31md \e[0m\e[31mg \e[0m\e[31mj \e[0m\n" +
+      "\e[34mb \e[0m\e[34me \e[0m\e[34mh \e[0m\e[34mk \e[0m\n" +
+      "\e[31mc \e[0m\e[31mf \e[0m\e[31mi \e[0m\e[31ml \e[0m\n"
+    )
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/08_table.md

@@ -0,0 +1,28 @@
+# ANSI::Table
+
+The ANSI::Table class can be used to output tabular data with nicely
+formated ASCII cell borders.
+
+    require 'ansi/table'
+
+The constructor takes an 2-dimensional array.
+
+    data = [
+      [ 10, 20, 30 ],
+      [ 20, 10, 20 ],
+      [ 50, 40, 20 ]
+    ]
+
+    table = ANSI::Table.new(data)
+
+    table.to_s
+
+The output will be:
+
+    +----+----+----+
+    | 10 | 20 | 30 |
+    | 20 | 10 | 20 |
+    | 50 | 40 | 20 |
+    +----+----+----+
+
+

data/vendor/bundle/ruby/2.6.0/gems/ansi-1.5.0/demo/09_diff.md

@@ -0,0 +1,47 @@
+# ANSI::Diff
+
+    require 'ansi/diff'
+
+    a = 'abcYefg'
+    b = 'abcXefg'
+
+    diff = ANSI::Diff.new(a,b)
+
+    diff.to_s.assert == "\e[31mabc\e[0m\e[33mYefg\e[0m\n\e[31mabc\e[0mXefg"
+
+Try another.
+
+    a = 'abc'
+    b = 'abcdef'
+
+    diff = ANSI::Diff.new(a,b)
+
+    diff.to_s.assert == "\e[31mabc\e[0m\n\e[31mabc\e[0mdef"
+
+And another.
+
+    a = 'abcXXXghi'
+    b = 'abcdefghi'
+
+    diff = ANSI::Diff.new(a,b)
+
+    diff.to_s.assert == "\e[31mabc\e[0m\e[33mXXXghi\e[0m\n\e[31mabc\e[0mdefghi"
+
+And another.
+
+    a = 'abcXXXdefghi'
+    b = 'abcdefghi'
+
+    diff = ANSI::Diff.new(a,b)
+
+    diff.to_s.assert == "\e[31mabc\e[0m\e[33mXXX\e[0m\e[35mdefghi\e[0m\n\e[31mabc\e[0m\e[35mdefghi\e[0m"
+
+Comparison that is mostly different.
+
+    a = 'abcpppz123'
+    b = 'abcxyzzz43'
+
+    diff = ANSI::Diff.new(a,b)
+
+    diff.to_s.assert == "\e[31mabc\e[0m\e[33mpppz123\e[0m\n\e[31mabc\e[0mxyzzz43"
+