diff --git a/src/eFmt.erl b/src/eFmt.erl
index a4adc2e..9959397 100644
--- a/src/eFmt.erl
+++ b/src/eFmt.erl
@@ -1,3 +1,969 @@
 -module(eFmt).
 
--export([]).
+-export([fwrite/2,fread/2,fread/3,format/2]).
+-export([scan_format/2,unscan_format/1,build_text/1]).
+-export([print/1,print/4,indentation/2]).
+
+-export([write/1,write/2,write/3,nl/0,format_prompt/1,format_prompt/2]).
+-export([write_atom/1,write_string/1,write_string/2,write_latin1_string/1,
+   write_latin1_string/2, write_char/1, write_latin1_char/1]).
+
+-export([write_atom_as_latin1/1, write_string_as_latin1/1,
+   write_string_as_latin1/2, write_char_as_latin1/1]).
+
+-export([quote_atom/2, char_list/1, latin1_char_list/1,
+   deep_char_list/1, deep_latin1_char_list/1,
+   printable_list/1, printable_latin1_list/1, printable_unicode_list/1]).
+
+%% Utilities for collecting characters.
+-export([collect_chars/3, collect_chars/4,
+   collect_line/2, collect_line/3, collect_line/4,
+   get_until/3, get_until/4]).
+
+%% The following functions were used by Yecc's include-file.
+-export([write_unicode_string/1, write_unicode_char/1,
+   deep_unicode_char_list/1]).
+
+-export([limit_term/2]).
+
+-export_type([chars/0, latin1_string/0, continuation/0,
+   fread_error/0, fread_item/0, format_spec/0]).
+
+%%----------------------------------------------------------------------
+
+-type chars() :: [char() | chars()].
+-type latin1_string() :: [unicode:latin1_char()].
+-type depth() :: -1 | non_neg_integer().
+
+-opaque continuation() :: {Format :: string(),
+   Stack :: chars(),
+   Nchars :: non_neg_integer(),
+   Results :: [term()]}.
+
+-type fread_error() :: 'atom'
+| 'based'
+| 'character'
+| 'float'
+| 'format'
+| 'input'
+| 'integer'
+| 'string'
+| 'unsigned'.
+
+-type fread_item() :: string() | atom() | integer() | float().
+
+-type format_spec() ::
+#{
+control_char := char(),
+args         := [any()],
+width        := 'none' | integer(),
+adjust       := 'left' | 'right',
+precision    := 'none' | integer(),
+pad_char     := char(),
+encoding     := 'unicode' | 'latin1',
+strings      := boolean()
+}.
+
+%%----------------------------------------------------------------------
+
+%% Interface calls to sub-modules.
+
+-spec fwrite(Format, Data) -> chars() when
+   Format :: io:format(),
+   Data :: [term()].
+
+fwrite(Format, Args) ->
+   format(Format, Args).
+
+-spec fread(Format, String) -> Result when
+   Format :: string(),
+   String :: string(),
+   Result :: {'ok', InputList :: [fread_item()], LeftOverChars :: string()}
+   | {'more', RestFormat :: string(),
+      Nchars :: non_neg_integer(),
+      InputStack :: chars()}
+   | {'error', {'fread', What :: fread_error()}}.
+
+fread(Chars, Format) ->
+   io_lib_fread:fread(Chars, Format).
+
+-spec fread(Continuation, CharSpec, Format) -> Return when
+   Continuation :: continuation() | [],
+   CharSpec :: string() | eof,
+   Format :: string(),
+   Return :: {'more', Continuation1 :: continuation()}
+   | {'done', Result, LeftOverChars :: string()},
+   Result :: {'ok', InputList :: [fread_item()]}
+   | 'eof'
+   | {'error', {'fread', What :: fread_error()}}.
+
+fread(Cont, Chars, Format) ->
+   io_lib_fread:fread(Cont, Chars, Format).
+
+-spec format(Format, Data) -> chars() when
+   Format :: io:format(),
+   Data :: [term()].
+
+format(Format, Args) ->
+   case catch io_lib_format:fwrite(Format, Args) of
+      {'EXIT',_} ->
+         erlang:error(badarg, [Format, Args]);
+      Other ->
+         Other
+   end.
+
+-spec scan_format(Format, Data) -> FormatList when
+   Format :: io:format(),
+   Data :: [term()],
+   FormatList :: [char() | format_spec()].
+
+scan_format(Format, Args) ->
+   try io_lib_format:scan(Format, Args)
+   catch
+      _:_ -> erlang:error(badarg, [Format, Args])
+   end.
+
+-spec unscan_format(FormatList) -> {Format, Data} when
+   FormatList :: [char() | format_spec()],
+   Format :: io:format(),
+   Data :: [term()].
+
+unscan_format(FormatList) ->
+   io_lib_format:unscan(FormatList).
+
+-spec build_text(FormatList) -> chars() when
+   FormatList :: [char() | format_spec()].
+
+build_text(FormatList) ->
+   io_lib_format:build(FormatList).
+
+-spec print(Term) -> chars() when
+   Term :: term().
+
+print(Term) ->
+   io_lib_pretty:print(Term).
+
+-spec print(Term, Column, LineLength, Depth) -> chars() when
+   Term :: term(),
+   Column :: non_neg_integer(),
+   LineLength :: non_neg_integer(),
+   Depth :: depth().
+
+print(Term, Column, LineLength, Depth) ->
+   io_lib_pretty:print(Term, Column, LineLength, Depth).
+
+-spec indentation(String, StartIndent) -> integer() when
+   String :: string(),
+   StartIndent :: integer().
+
+indentation(Chars, Current) ->
+   io_lib_format:indentation(Chars, Current).
+
+
+%% Format an IO-request prompt (handles formatting errors safely).
+%% Atoms, binaries, and iolists (or unicode:charlist()) can be used
+%% as-is, and will be printed without any additional quotes.
+
+-spec format_prompt(term()) -> chars().
+
+format_prompt(Prompt) ->
+   format_prompt(Prompt, latin1).
+
+-spec format_prompt(term(), atom()) -> chars().
+
+format_prompt({format,Format,Args}, _Encoding) ->
+   do_format_prompt(Format, Args);
+format_prompt(Prompt, Encoding)
+   when is_list(Prompt); is_atom(Prompt); is_binary(Prompt) ->
+   do_format_prompt(add_modifier(Encoding, "s"), [Prompt]);
+format_prompt(Prompt, Encoding) ->
+   do_format_prompt(add_modifier(Encoding, "p"), [Prompt]).
+
+do_format_prompt(Format, Args) ->
+   case catch eFmt:format(Format, Args) of
+      {'EXIT',_} -> "???";
+      List -> List
+   end.
+
+add_modifier(latin1, C) ->
+   "~"++C;
+add_modifier(_, C) ->
+   "~t"++C.
+
+%% write(Term)
+%% write(Term, Depth)
+%% write(Term, Depth, Pretty)
+%%  Return a (non-flattened) list of characters giving a printed
+%%  representation of the term. write/3 is for backward compatibility.
+
+-spec write(Term) -> chars() when
+   Term :: term().
+
+write(Term) -> write(Term, -1).
+
+-spec write(term(), depth(), boolean()) -> chars().
+
+write(Term, D, true) ->
+   io_lib_pretty:print(Term, 1, 80, D);
+write(Term, D, false) ->
+   write(Term, D).
+
+-spec write(Term, Depth) -> chars() when
+   Term :: term(),
+   Depth :: depth();
+   (Term, Options) -> chars() when
+   Term :: term(),
+   Options :: [Option],
+   Option :: {'depth', Depth}
+   | {'encoding', 'latin1' | 'utf8' | 'unicode'},
+   Depth :: depth().
+
+write(Term, Options) when is_list(Options) ->
+   Depth = get_option(depth, Options, -1),
+   Encoding = get_option(encoding, Options, epp:default_encoding()),
+   write1(Term, Depth, Encoding);
+write(Term, Depth) ->
+   write1(Term, Depth, latin1).
+
+write1(_Term, 0, _E) -> "...";
+write1(Term, _D, _E) when is_integer(Term) -> integer_to_list(Term);
+write1(Term, _D, _E) when is_float(Term) -> io_lib_format:fwrite_g(Term);
+write1(Atom, _D, latin1) when is_atom(Atom) -> write_atom_as_latin1(Atom);
+write1(Atom, _D, _E) when is_atom(Atom) -> write_atom(Atom);
+write1(Term, _D, _E) when is_port(Term) -> write_port(Term);
+write1(Term, _D, _E) when is_pid(Term) -> pid_to_list(Term);
+write1(Term, _D, _E) when is_reference(Term) -> write_ref(Term);
+write1(<<_/bitstring>>=Term, D, _E) -> write_binary(Term, D);
+write1([], _D, _E) -> "[]";
+write1({}, _D, _E) -> "{}";
+write1([H|T], D, E) ->
+   if
+      D =:= 1 -> "[...]";
+      true ->
+         [$[,[write1(H, D-1, E)|write_tail(T, D-1, E, $|)],$]]
+   end;
+write1(F, _D, _E) when is_function(F) ->
+   erlang:fun_to_list(F);
+write1(Term, D, E) when is_map(Term) ->
+   write_map(Term, D, E);
+write1(T, D, E) when is_tuple(T) ->
+   if
+      D =:= 1 -> "{...}";
+      true ->
+         [${,
+            [write1(element(1, T), D-1, E)|
+               write_tail(tl(tuple_to_list(T)), D-1, E, $,)],
+            $}]
+   end.
+
+%% write_tail(List, Depth, CharacterBeforeDots)
+%%  Test the terminating case first as this looks better with depth.
+
+write_tail([], _D, _E, _S) -> "";
+write_tail(_, 1, _E, S) -> [S | "..."];
+write_tail([H|T], D, E, S) ->
+   [$,,write1(H, D-1, E)|write_tail(T, D-1, E, S)];
+write_tail(Other, D, E, S) ->
+   [S,write1(Other, D-1, E)].
+
+write_port(Port) ->
+   erlang:port_to_list(Port).
+
+write_ref(Ref) ->
+   erlang:ref_to_list(Ref).
+
+write_map(Map, D, E) when is_integer(D) ->
+   [$#,${,write_map_body(maps:to_list(Map), D, E),$}].
+
+write_map_body(_, 0, _E) -> "...";
+write_map_body([], _, _E) -> [];
+write_map_body([{K,V}], D, E) -> write_map_assoc(K, V, D, E);
+write_map_body([{K,V}|KVs], D, E) ->
+   [write_map_assoc(K, V, D, E),$, | write_map_body(KVs, D-1, E)].
+
+write_map_assoc(K, V, D, E) ->
+   [write1(K, D - 1, E),"=>",write1(V, D-1, E)].
+
+write_binary(B, D) when is_integer(D) ->
+   [$<,$<,write_binary_body(B, D),$>,$>].
+
+write_binary_body(<<>>, _D) ->
+   "";
+write_binary_body(_B, 1) ->
+   "...";
+write_binary_body(<<X:8>>, _D) ->
+   [integer_to_list(X)];
+write_binary_body(<<X:8,Rest/bitstring>>, D) ->
+   [integer_to_list(X),$,|write_binary_body(Rest, D-1)];
+write_binary_body(B, _D) ->
+   L = bit_size(B),
+   <<X:L>> = B,
+   [integer_to_list(X),$:,integer_to_list(L)].
+
+get_option(Key, TupleList, Default) ->
+   case lists:keyfind(Key, 1, TupleList) of
+      false -> Default;
+      {Key, Value} -> Value;
+      _ -> Default
+   end.
+
+%%% There are two functions to write Unicode atoms:
+%%% - they both escape control characters < 160;
+%%% - write_atom() never escapes characters >= 160;
+%%% - write_atom_as_latin1() also escapes characters >= 255.
+
+%% write_atom(Atom) -> [Char]
+%%  Generate the list of characters needed to print an atom.
+
+-spec write_atom(Atom) -> chars() when
+   Atom :: atom().
+
+write_atom(Atom) ->
+   write_possibly_quoted_atom(Atom, fun write_string/2).
+
+-spec write_atom_as_latin1(Atom) -> latin1_string() when
+   Atom :: atom().
+
+write_atom_as_latin1(Atom) ->
+   write_possibly_quoted_atom(Atom, fun write_string_as_latin1/2).
+
+write_possibly_quoted_atom(Atom, PFun) ->
+   Chars = atom_to_list(Atom),
+   case quote_atom(Atom, Chars) of
+      true ->
+         PFun(Chars, $');   %'
+      false ->
+         Chars
+   end.
+
+%% quote_atom(Atom, CharList)
+%%  Return 'true' if atom with chars in CharList needs to be quoted, else
+%%  return 'false'. Notice that characters >= 160 are always quoted.
+
+-spec quote_atom(atom(), chars()) -> boolean().
+
+quote_atom(Atom, Cs0) ->
+   case erl_scan:reserved_word(Atom) of
+      true -> true;
+      false ->
+         case Cs0 of
+            [C|Cs] when C >= $a, C =< $z ->
+               not name_chars(Cs);
+            [C|Cs] when C >= $ß, C =< $ÿ, C =/= $÷ ->
+               not name_chars(Cs);
+            _ -> true
+         end
+   end.
+
+name_chars([C|Cs]) ->
+   case name_char(C) of
+      true -> name_chars(Cs);
+      false -> false
+   end;
+name_chars([]) -> true.
+
+name_char(C) when C >= $a, C =< $z -> true;
+name_char(C) when C >= $ß, C =< $ÿ, C =/= $÷ -> true;
+name_char(C) when C >= $A, C =< $Z -> true;
+name_char(C) when C >= $À, C =< $Þ, C =/= $× -> true;
+name_char(C) when C >= $0, C =< $9 -> true;
+name_char($_) -> true;
+name_char($@) -> true;
+name_char(_) -> false.
+
+%%% There are two functions to write Unicode strings:
+%%% - they both escape control characters < 160;
+%%% - write_string() never escapes characters >= 160;
+%%% - write_string_as_latin1() also escapes characters >= 255.
+
+%% write_string([Char]) -> [Char]
+%%  Generate the list of characters needed to print a string.
+
+-spec write_string(String) -> chars() when
+   String :: string().
+
+write_string(S) ->
+   write_string(S, $").   %"
+
+-spec write_string(string(), char()) -> chars().
+
+write_string(S, Q) ->
+   [Q|write_string1(unicode_as_unicode, S, Q)].
+
+%% Backwards compatibility.
+write_unicode_string(S) ->
+   write_string(S).
+
+-spec write_latin1_string(Latin1String) -> latin1_string() when
+   Latin1String :: latin1_string().
+
+write_latin1_string(S) ->
+   write_latin1_string(S, $").   %"
+
+-spec write_latin1_string(latin1_string(), char()) -> latin1_string().
+
+write_latin1_string(S, Q) ->
+   [Q|write_string1(latin1, S, Q)].
+
+-spec write_string_as_latin1(String) -> latin1_string() when
+   String :: string().
+
+write_string_as_latin1(S) ->
+   write_string_as_latin1(S, $").   %"
+
+-spec write_string_as_latin1(string(), char()) -> latin1_string().
+
+write_string_as_latin1(S, Q) ->
+   [Q|write_string1(unicode_as_latin1, S, Q)].
+
+write_string1(_,[], Q) ->
+   [Q];
+write_string1(Enc,[C|Cs], Q) ->
+   string_char(Enc,C, Q, write_string1(Enc,Cs, Q)).
+
+string_char(_,Q, Q, Tail) -> [$\\,Q|Tail];	%Must check these first!
+string_char(_,$\\, _, Tail) -> [$\\,$\\|Tail];
+string_char(_,C, _, Tail) when C >= $\s, C =< $~ ->
+   [C|Tail];
+string_char(latin1,C, _, Tail) when C >= $\240, C =< $\377 ->
+   [C|Tail];
+string_char(unicode_as_unicode,C, _, Tail) when C >= $\240 ->
+   [C|Tail];
+string_char(unicode_as_latin1,C, _, Tail) when C >= $\240, C =< $\377 ->
+   [C|Tail];
+string_char(unicode_as_latin1,C, _, Tail) when C >= $\377 ->
+   "\\x{"++erlang:integer_to_list(C, 16)++"}"++Tail;
+string_char(_,$\n, _, Tail) -> [$\\,$n|Tail];	%\n = LF
+string_char(_,$\r, _, Tail) -> [$\\,$r|Tail];	%\r = CR
+string_char(_,$\t, _, Tail) -> [$\\,$t|Tail];	%\t = TAB
+string_char(_,$\v, _, Tail) -> [$\\,$v|Tail];	%\v = VT
+string_char(_,$\b, _, Tail) -> [$\\,$b|Tail];	%\b = BS
+string_char(_,$\f, _, Tail) -> [$\\,$f|Tail];	%\f = FF
+string_char(_,$\e, _, Tail) -> [$\\,$e|Tail];	%\e = ESC
+string_char(_,$\d, _, Tail) -> [$\\,$d|Tail];	%\d = DEL
+string_char(_,C, _, Tail) when C < $\240->	%Other control characters.
+   C1 = (C bsr 6) + $0,
+   C2 = ((C bsr 3) band 7) + $0,
+   C3 = (C band 7) + $0,
+   [$\\,C1,C2,C3|Tail].
+
+%%% There are two functions to write a Unicode character:
+%%% - they both escape control characters < 160;
+%%% - write_char() never escapes characters >= 160;
+%%% - write_char_as_latin1() also escapes characters >= 255.
+
+%% write_char(Char) -> [char()].
+%%  Generate the list of characters needed to print a character constant.
+%%  Must special case SPACE, $\s, here.
+
+-spec write_char(Char) -> chars() when
+   Char :: char().
+
+write_char($\s) -> "$\\s";			%Must special case this.
+write_char(C) when is_integer(C), C >= $\000 ->
+   [$$|string_char(unicode_as_unicode, C, -1, [])].
+
+%% Backwards compatibility.
+write_unicode_char(C) ->
+   write_char(C).
+
+-spec write_latin1_char(Latin1Char) -> latin1_string() when
+   Latin1Char :: unicode:latin1_char().
+
+write_latin1_char(Lat1) when is_integer(Lat1), Lat1 >= $\000, Lat1 =< $\377  ->
+   [$$|string_char(latin1, Lat1, -1, [])].
+
+-spec write_char_as_latin1(Char) -> latin1_string() when
+   Char :: char().
+
+write_char_as_latin1(Uni) when is_integer(Uni), Uni >= $\000 ->
+   [$$|string_char(unicode_as_latin1,Uni, -1, [])].
+
+%% latin1_char_list(CharList)
+%% deep_latin1_char_list(CharList)
+%%  Return true if CharList is a (possibly deep) list of Latin-1
+%%  characters, else false.
+
+-spec latin1_char_list(Term) -> boolean() when
+   Term :: term().
+
+latin1_char_list([C|Cs]) when is_integer(C), C >= $\000, C =< $\377 ->
+   latin1_char_list(Cs);
+latin1_char_list([]) -> true;
+latin1_char_list(_) -> false.			%Everything else is false
+
+-spec char_list(Term) -> boolean() when
+   Term :: term().
+
+char_list([C|Cs]) when is_integer(C), C >= 0, C < 16#D800;
+   is_integer(C), C > 16#DFFF, C < 16#FFFE;
+   is_integer(C), C > 16#FFFF, C =< 16#10FFFF ->
+   char_list(Cs);
+char_list([]) -> true;
+char_list(_) -> false.			%Everything else is false
+
+-spec deep_latin1_char_list(Term) -> boolean() when
+   Term :: term().
+
+deep_latin1_char_list(Cs) ->
+   deep_latin1_char_list(Cs, []).
+
+deep_latin1_char_list([C|Cs], More) when is_list(C) ->
+   deep_latin1_char_list(C, [Cs|More]);
+deep_latin1_char_list([C|Cs], More) when is_integer(C), C >= $\000, C =< $\377 ->
+   deep_latin1_char_list(Cs, More);
+deep_latin1_char_list([], [Cs|More]) ->
+   deep_latin1_char_list(Cs, More);
+deep_latin1_char_list([], []) -> true;
+deep_latin1_char_list(_, _More) ->			%Everything else is false
+   false.
+
+-spec deep_char_list(Term) -> boolean() when
+   Term :: term().
+
+deep_char_list(Cs) ->
+   deep_char_list(Cs, []).
+
+deep_char_list([C|Cs], More) when is_list(C) ->
+   deep_char_list(C, [Cs|More]);
+deep_char_list([C|Cs], More)
+   when is_integer(C), C >= 0, C < 16#D800;
+   is_integer(C), C > 16#DFFF, C < 16#FFFE;
+   is_integer(C), C > 16#FFFF, C =< 16#10FFFF ->
+   deep_char_list(Cs, More);
+deep_char_list([], [Cs|More]) ->
+   deep_char_list(Cs, More);
+deep_char_list([], []) -> true;
+deep_char_list(_, _More) ->		%Everything else is false
+   false.
+
+deep_unicode_char_list(Term) ->
+   deep_char_list(Term).
+
+%% printable_latin1_list([Char]) -> boolean()
+%%  Return true if CharList is a list of printable Latin1 characters, else
+%%  false.
+
+-spec printable_latin1_list(Term) -> boolean() when
+   Term :: term().
+
+printable_latin1_list([C|Cs]) when is_integer(C), C >= $\040, C =< $\176 ->
+   printable_latin1_list(Cs);
+printable_latin1_list([C|Cs]) when is_integer(C), C >= $\240, C =< $\377 ->
+   printable_latin1_list(Cs);
+printable_latin1_list([$\n|Cs]) -> printable_latin1_list(Cs);
+printable_latin1_list([$\r|Cs]) -> printable_latin1_list(Cs);
+printable_latin1_list([$\t|Cs]) -> printable_latin1_list(Cs);
+printable_latin1_list([$\v|Cs]) -> printable_latin1_list(Cs);
+printable_latin1_list([$\b|Cs]) -> printable_latin1_list(Cs);
+printable_latin1_list([$\f|Cs]) -> printable_latin1_list(Cs);
+printable_latin1_list([$\e|Cs]) -> printable_latin1_list(Cs);
+printable_latin1_list([]) -> true;
+printable_latin1_list(_) -> false.			%Everything else is false
+
+%% printable_list([Char]) -> boolean()
+%%  Return true if CharList is a list of printable characters, else
+%%  false. The notion of printable in Unicode terms is somewhat floating.
+%%  Everything that is not a control character and not invalid unicode
+%%  will be considered printable.
+%%  What the user has noted as printable characters is what actually
+%%  specifies when this function will return true. If the VM is started
+%%  with +pc latin1, only the latin1 range will be deemed as printable
+%%  if on the other hand +pc unicode is given, all characters in the Unicode
+%%  character set are deemed printable. latin1 is default.
+
+-spec printable_list(Term) -> boolean() when
+   Term :: term().
+
+printable_list(L) ->
+   %% There will be more alternatives returns from io:printable range
+   %% in the future. To not have a catch-all clause is deliberate.
+   case io:printable_range() of
+      latin1 ->
+         printable_latin1_list(L);
+      unicode ->
+         printable_unicode_list(L)
+   end.
+
+-spec printable_unicode_list(Term) -> boolean() when
+   Term :: term().
+
+printable_unicode_list([C|Cs]) when is_integer(C), C >= $\040, C =< $\176 ->
+   printable_unicode_list(Cs);
+printable_unicode_list([C|Cs])
+   when is_integer(C), C >= 16#A0, C < 16#D800;
+   is_integer(C), C > 16#DFFF, C < 16#FFFE;
+   is_integer(C), C > 16#FFFF, C =< 16#10FFFF ->
+   printable_unicode_list(Cs);
+printable_unicode_list([$\n|Cs]) -> printable_unicode_list(Cs);
+printable_unicode_list([$\r|Cs]) -> printable_unicode_list(Cs);
+printable_unicode_list([$\t|Cs]) -> printable_unicode_list(Cs);
+printable_unicode_list([$\v|Cs]) -> printable_unicode_list(Cs);
+printable_unicode_list([$\b|Cs]) -> printable_unicode_list(Cs);
+printable_unicode_list([$\f|Cs]) -> printable_unicode_list(Cs);
+printable_unicode_list([$\e|Cs]) -> printable_unicode_list(Cs);
+printable_unicode_list([]) -> true;
+printable_unicode_list(_) -> false.		%Everything else is false
+
+%% List = nl()
+%%  Return a list of characters to generate a newline.
+
+-spec nl() -> string().
+
+nl() ->
+   "\n".
+
+%%
+%% Utilities for collecting characters in input files
+%%
+
+count_and_find_utf8(Bin,N) ->
+   cafu(Bin,N,0,0,none).
+
+cafu(<<>>,_N,Count,_ByteCount,SavePos) ->
+   {Count,SavePos};
+cafu(<<_/utf8,Rest/binary>>, 0, Count, ByteCount, _SavePos) ->
+   cafu(Rest,-1,Count+1,0,ByteCount);
+cafu(<<_/utf8,Rest/binary>>, N, Count, _ByteCount, SavePos) when N < 0 ->
+   cafu(Rest,-1,Count+1,0,SavePos);
+cafu(<<_/utf8,Rest/binary>> = Whole, N, Count, ByteCount, SavePos) ->
+   Delta = byte_size(Whole) - byte_size(Rest),
+   cafu(Rest,N-1,Count+1,ByteCount+Delta,SavePos);
+cafu(_Other,_N,Count,_ByteCount,SavePos) -> % Non Utf8 character at end
+   {Count,SavePos}.
+
+%% collect_chars(State, Data, Count). New in R9C.
+%%  Returns:
+%%      {stop,Result,RestData}
+%%      NewState
+%%% BC (with pre-R13).
+collect_chars(Tag, Data, N) ->
+   collect_chars(Tag, Data, latin1, N).
+
+%% Now we are aware of encoding...
+collect_chars(start, Data, unicode, N) when is_binary(Data) ->
+   {Size,Npos} = count_and_find_utf8(Data,N),
+   if Size > N ->
+      {B1,B2} = split_binary(Data, Npos),
+      {stop,B1,B2};
+      Size < N ->
+         {binary,[Data],N-Size};
+      true ->
+         {stop,Data,eof}
+   end;
+collect_chars(start, Data, latin1, N) when is_binary(Data) ->
+   Size = byte_size(Data),
+   if Size > N ->
+      {B1,B2} = split_binary(Data, N),
+      {stop,B1,B2};
+      Size < N ->
+         {binary,[Data],N-Size};
+      true ->
+         {stop,Data,eof}
+   end;
+collect_chars(start,Data,_,N) when is_list(Data) ->
+   collect_chars_list([], N, Data);
+collect_chars(start, eof, _,_) ->
+   {stop,eof,eof};
+collect_chars({binary,Stack,_N}, eof, _,_) ->
+   {stop,binrev(Stack),eof};
+collect_chars({binary,Stack,N}, Data,unicode, _) ->
+   {Size,Npos} = count_and_find_utf8(Data,N),
+   if Size > N ->
+      {B1,B2} = split_binary(Data, Npos),
+      {stop,binrev(Stack, [B1]),B2};
+      Size < N ->
+         {binary,[Data|Stack],N-Size};
+      true ->
+         {stop,binrev(Stack, [Data]),eof}
+   end;
+collect_chars({binary,Stack,N}, Data,latin1, _) ->
+   Size = byte_size(Data),
+   if Size > N ->
+      {B1,B2} = split_binary(Data, N),
+      {stop,binrev(Stack, [B1]),B2};
+      Size < N ->
+         {binary,[Data|Stack],N-Size};
+      true ->
+         {stop,binrev(Stack, [Data]),eof}
+   end;
+collect_chars({list,Stack,N}, Data, _,_) ->
+   collect_chars_list(Stack, N, Data);
+%% collect_chars(Continuation, MoreChars, Count)
+%%  Returns:
+%%	{done,Result,RestChars}
+%%	{more,Continuation}
+
+collect_chars([], Chars, _, N) ->
+   collect_chars1(N, Chars, []);
+collect_chars({Left,Sofar}, Chars, _, _N) ->
+   collect_chars1(Left, Chars, Sofar).
+
+collect_chars1(N, Chars, Stack) when N =< 0 ->
+   {done,lists:reverse(Stack, []),Chars};
+collect_chars1(N, [C|Rest], Stack) ->
+   collect_chars1(N-1, Rest, [C|Stack]);
+collect_chars1(_N, eof, []) ->
+   {done,eof,[]};
+collect_chars1(_N, eof, Stack) ->
+   {done,lists:reverse(Stack, []),[]};
+collect_chars1(N, [], Stack) ->
+   {more,{N,Stack}}.
+
+collect_chars_list(Stack, 0, Data) ->
+   {stop,lists:reverse(Stack, []),Data};
+collect_chars_list(Stack, _N, eof) ->
+   {stop,lists:reverse(Stack, []),eof};
+collect_chars_list(Stack, N, []) ->
+   {list,Stack,N};
+collect_chars_list(Stack,N, [H|T]) ->
+   collect_chars_list([H|Stack], N-1, T).
+
+%% collect_line(Continuation, MoreChars)
+%%  Returns:
+%%	{done,Result,RestChars}
+%%	{more,Continuation}
+%%
+%%  XXX Can be removed when compatibility with pre-R12B-5 nodes
+%%  is no longer required.
+%%
+collect_line([], Chars) ->
+   collect_line1(Chars, []);
+collect_line({SoFar}, More) ->
+   collect_line1(More, SoFar).
+
+collect_line1([$\r, $\n|Rest], Stack) ->
+   collect_line1([$\n|Rest], Stack);
+collect_line1([$\n|Rest], Stack) ->
+   {done,lists:reverse([$\n|Stack], []),Rest};
+collect_line1([C|Rest], Stack) ->
+   collect_line1(Rest, [C|Stack]);
+collect_line1(eof, []) ->
+   {done,eof,[]};
+collect_line1(eof, Stack) ->
+   {done,lists:reverse(Stack, []),[]};
+collect_line1([], Stack) ->
+   {more,{Stack}}.
+
+%% collect_line(State, Data, _). New in R9C.
+%%  Returns:
+%%	{stop,Result,RestData}
+%%	NewState
+%%% BC (with pre-R13).
+collect_line(Tag, Data, Any) ->
+   collect_line(Tag, Data, latin1, Any).
+
+%% Now we are aware of encoding...
+collect_line(start, Data, Encoding, _) when is_binary(Data) ->
+   collect_line_bin(Data, Data, [], Encoding);
+collect_line(start, Data, _, _) when is_list(Data) ->
+   collect_line_list(Data, []);
+collect_line(start, eof, _, _) ->
+   {stop,eof,eof};
+collect_line(Stack, Data, Encoding, _) when is_binary(Data) ->
+   collect_line_bin(Data, Data, Stack, Encoding);
+collect_line(Stack, Data, _, _) when is_list(Data) ->
+   collect_line_list(Data, Stack);
+collect_line([B|_]=Stack, eof, _, _) when is_binary(B) ->
+   {stop,binrev(Stack),eof};
+collect_line(Stack, eof, _, _) ->
+   {stop,lists:reverse(Stack, []),eof}.
+
+
+collect_line_bin(<<$\n,T/binary>>, Data, Stack0, _) ->
+   N = byte_size(Data) - byte_size(T),
+   <<Line:N/binary,_/binary>> = Data,
+   case Stack0 of
+      [] ->
+         {stop,Line,T};
+      [<<$\r>>|Stack] when N =:= 1 ->
+         {stop,binrev(Stack, [$\n]),T};
+      _ ->
+         {stop,binrev(Stack0, [Line]),T}
+   end;
+collect_line_bin(<<$\r,$\n,T/binary>>, Data, Stack, _) ->
+   N = byte_size(Data) - byte_size(T) - 2,
+   <<Line:N/binary,_/binary>> = Data,
+   {stop,binrev(Stack, [Line,$\n]),T};
+collect_line_bin(<<$\r>>, Data0, Stack, _) ->
+   N = byte_size(Data0) - 1,
+   <<Data:N/binary,_/binary>> = Data0,
+   [<<$\r>>,Data|Stack];
+collect_line_bin(<<_,T/binary>>, Data, Stack, Enc) ->
+   collect_line_bin(T, Data, Stack, Enc);
+collect_line_bin(<<>>, Data, Stack, _) ->
+   %% Need more data here.
+   [Data|Stack].
+
+collect_line_list([$\n|T], [$\r|Stack]) ->
+   {stop,lists:reverse(Stack, [$\n]),T};
+collect_line_list([$\n|T], Stack) ->
+   {stop,lists:reverse(Stack, [$\n]),T};
+collect_line_list([H|T], Stack) ->
+   collect_line_list(T, [H|Stack]);
+collect_line_list([], Stack) ->
+   Stack.
+
+%% Translator function to emulate a new (R9C and later)
+%% I/O client when you have an old one.
+%%
+%% Implements a middleman that is get_until server and get_chars client.
+
+%%% BC (with pre-R13).
+get_until(Any,Data,Arg) ->
+   get_until(Any,Data,latin1,Arg).
+
+%% Now we are aware of encoding...
+get_until(start, Data, Encoding, XtraArg) ->
+   get_until([], Data, Encoding, XtraArg);
+get_until(Cont, Data, Encoding, {Mod, Func, XtraArgs}) ->
+   Chars = if is_binary(Data), Encoding =:= unicode ->
+      unicode:characters_to_list(Data,utf8);
+              is_binary(Data) ->
+                 binary_to_list(Data);
+              true ->
+                 Data
+           end,
+   case apply(Mod, Func, [Cont,Chars|XtraArgs]) of
+      {done,Result,Buf} ->
+         {stop,if is_binary(Data),
+         is_list(Result),
+         Encoding =:= unicode ->
+            unicode:characters_to_binary(Result,unicode,unicode);
+                  is_binary(Data),
+                  is_list(Result) ->
+                     erlang:iolist_to_binary(Result);
+%%		     is_list(Data),
+%%		     is_list(Result),
+%% 		     Encoding =:= latin1 ->
+%% 			  % Should check for only latin1, but skip that for
+%% 			  % efficiency reasons.
+%% 			  [ exit({cannot_convert, unicode, latin1}) ||
+%% 			      X <- List, X > 255 ];
+                  true ->
+                     Result
+               end,
+            Buf};
+      {more,NewCont} ->
+         NewCont
+   end.
+
+binrev(L) ->
+   list_to_binary(lists:reverse(L, [])).
+
+binrev(L, T) ->
+   list_to_binary(lists:reverse(L, T)).
+
+-spec limit_term(term(), non_neg_integer()) -> term().
+
+%% The intention is to mimic the depth limitation of eFmt:write()
+%% and io_lib_pretty:print(). The leaves ('...') should never be
+%% seen when printed with the same depth. Bitstrings are never
+%% truncated, which is OK as long as they are not sent to other nodes.
+limit_term(Term, Depth) ->
+   try test_limit(Term, Depth) of
+      ok -> Term
+   catch
+      throw:limit ->
+         limit(Term, Depth)
+   end.
+
+limit(_, 0) -> '...';
+limit([H|T]=L, D) ->
+   if
+      D =:= 1 -> '...';
+      true ->
+         case printable_list(L) of
+            true -> L;
+            false ->
+               [limit(H, D-1)|limit_tail(T, D-1)]
+         end
+   end;
+limit(Term, D) when is_map(Term) ->
+   limit_map(Term, D);
+limit({}=T, _D) -> T;
+limit(T, D) when is_tuple(T) ->
+   if
+      D =:= 1 -> '...';
+      true ->
+         list_to_tuple([limit(element(1, T), D-1)|
+            limit_tail(tl(tuple_to_list(T)), D-1)])
+   end;
+limit(<<_/bitstring>>=Term, D) -> limit_bitstring(Term, D);
+limit(Term, _D) -> Term.
+
+limit_tail([], _D) -> [];
+limit_tail(_, 1) -> ['...'];
+limit_tail([H|T], D) ->
+   [limit(H, D-1)|limit_tail(T, D-1)];
+limit_tail(Other, D) ->
+   limit(Other, D-1).
+
+%% Cannot limit maps properly since there is no guarantee that
+%% maps:from_list() creates a map with the same internal ordering of
+%% the selected associations as in Map.
+limit_map(Map, D) ->
+   maps:from_list(erts_internal:maps_to_list(Map, D)).
+%%     maps:from_list(limit_map_body(erts_internal:maps_to_list(Map, D), D)).
+
+%% limit_map_body(_, 0) -> [{'...', '...'}];
+%% limit_map_body([], _) -> [];
+%% limit_map_body([{K,V}], D) -> [limit_map_assoc(K, V, D)];
+%% limit_map_body([{K,V}|KVs], D) ->
+%%     [limit_map_assoc(K, V, D) | limit_map_body(KVs, D-1)].
+
+%% limit_map_assoc(K, V, D) ->
+%%     {limit(K, D-1), limit(V, D-1)}.
+
+limit_bitstring(B, _D) -> B. %% Keeps all printable binaries.
+
+test_limit(_, 0) -> throw(limit);
+test_limit([H|T]=L, D) when is_integer(D) ->
+   if
+      D =:= 1 -> throw(limit);
+      true ->
+         case printable_list(L) of
+            true -> ok;
+            false ->
+               test_limit(H, D-1),
+               test_limit_tail(T, D-1)
+         end
+   end;
+test_limit(Term, D) when is_map(Term) ->
+   test_limit_map(Term, D);
+test_limit({}, _D) -> ok;
+test_limit(T, D) when is_tuple(T) ->
+   test_limit_tuple(T, 1, tuple_size(T), D);
+test_limit(<<_/bitstring>>=Term, D) -> test_limit_bitstring(Term, D);
+test_limit(_Term, _D) -> ok.
+
+test_limit_tail([], _D) -> ok;
+test_limit_tail(_, 1) -> throw(limit);
+test_limit_tail([H|T], D) ->
+   test_limit(H, D-1),
+   test_limit_tail(T, D-1);
+test_limit_tail(Other, D) ->
+   test_limit(Other, D-1).
+
+test_limit_tuple(_T, I, Sz, _D) when I > Sz -> ok;
+test_limit_tuple(_, _, _, 1) -> throw(limit);
+test_limit_tuple(T, I, Sz, D) ->
+   test_limit(element(I, T), D-1),
+   test_limit_tuple(T, I+1, Sz, D-1).
+
+test_limit_map(_Map, _D) -> ok.
+%%     test_limit_map_body(erts_internal:maps_to_list(Map, D), D).
+
+%% test_limit_map_body(_, 0) -> throw(limit);
+%% test_limit_map_body([], _) -> ok;
+%% test_limit_map_body([{K,V}], D) -> test_limit_map_assoc(K, V, D);
+%% test_limit_map_body([{K,V}|KVs], D) ->
+%%     test_limit_map_assoc(K, V, D),
+%%     test_limit_map_body(KVs, D-1).
+
+%% test_limit_map_assoc(K, V, D) ->
+%%     test_limit(K, D-1),
+%%     test_limit(V, D-1).
+
+test_limit_bitstring(_, _) -> ok.
+
diff --git a/src/eFmt_format.erl b/src/eFmt_format.erl
new file mode 100644
index 0000000..d4c2470
--- /dev/null
+++ b/src/eFmt_format.erl
@@ -0,0 +1,797 @@
+%%
+%% %CopyrightBegin%
+%% 
+%% Copyright Ericsson AB 1996-2017. All Rights Reserved.
+%% 
+%% Licensed under the Apache License, Version 2.0 (the "License");
+%% you may not use this file except in compliance with the License.
+%% You may obtain a copy of the License at
+%%
+%%     http://www.apache.org/licenses/LICENSE-2.0
+%%
+%% Unless required by applicable law or agreed to in writing, software
+%% distributed under the License is distributed on an "AS IS" BASIS,
+%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+%% See the License for the specific language governing permissions and
+%% limitations under the License.
+%% 
+%% %CopyrightEnd%
+%%
+-module(eFmt_format).
+
+%% Formatting functions of io library.
+
+-export([fwrite/2,fwrite_g/1,indentation/2,scan/2,unscan/1,build/1]).
+
+%%  Format the arguments in Args after string Format. Just generate
+%%  an error if there is an error in the arguments.
+%%
+%%  To do the printing command correctly we need to calculate the
+%%  current indentation for everything before it. This may be very
+%%  expensive, especially when it is not needed, so we first determine
+%%  if, and for how long, we need to calculate the indentations. We do
+%%  this by first collecting all the control sequences and
+%%  corresponding arguments, then counting the print sequences and
+%%  then building the output.  This method has some drawbacks, it does
+%%  two passes over the format string and creates more temporary data,
+%%  and it also splits the handling of the control characters into two
+%%  parts.
+
+-spec fwrite(Format, Data) -> FormatList when
+      Format :: io:format(),
+      Data :: [term()],
+      FormatList :: [char() | eFmt:format_spec()].
+
+fwrite(Format, Args) ->
+    build(scan(Format, Args)).
+
+%% Build the output text for a pre-parsed format list.
+
+-spec build(FormatList) -> eFmt:chars() when
+      FormatList :: [char() | eFmt:format_spec()].
+
+build(Cs) ->
+    Pc = pcount(Cs),
+    build(Cs, Pc, 0).
+
+%% Parse all control sequences in the format string.
+
+-spec scan(Format, Data) -> FormatList when
+      Format :: io:format(),
+      Data :: [term()],
+      FormatList :: [char() | eFmt:format_spec()].
+
+scan(Format, Args) when is_atom(Format) ->
+    scan(atom_to_list(Format), Args);
+scan(Format, Args) when is_binary(Format) ->
+    scan(binary_to_list(Format), Args);
+scan(Format, Args) ->
+    collect(Format, Args).
+
+%% Revert a pre-parsed format list to a plain character list and a
+%% list of arguments.
+
+-spec unscan(FormatList) -> {Format, Data} when
+      FormatList :: [char() | eFmt:format_spec()],
+      Format :: io:format(),
+      Data :: [term()].
+
+unscan(Cs) ->
+    {print(Cs), args(Cs)}.
+
+args([#{args := As} | Cs]) ->
+    As ++ args(Cs);
+args([_C | Cs]) ->
+    args(Cs);
+args([]) ->
+    [].
+
+print([#{control_char := C, width := F, adjust := Ad, precision := P,
+         pad_char := Pad, encoding := Encoding, strings := Strings} | Cs]) ->
+    print(C, F, Ad, P, Pad, Encoding, Strings) ++ print(Cs);
+print([C | Cs]) ->
+    [C | print(Cs)];
+print([]) ->
+    [].
+
+print(C, F, Ad, P, Pad, Encoding, Strings) ->
+    [$~] ++ print_field_width(F, Ad) ++ print_precision(P) ++
+        print_pad_char(Pad) ++ print_encoding(Encoding) ++
+        print_strings(Strings) ++ [C].
+
+print_field_width(none, _Ad) -> "";
+print_field_width(F, left) -> integer_to_list(-F);
+print_field_width(F, right) -> integer_to_list(F).
+
+print_precision(none) -> "";
+print_precision(P) -> [$. | integer_to_list(P)].
+
+print_pad_char($\s) -> ""; % default, no need to make explicit
+print_pad_char(Pad) -> [$., Pad].
+
+print_encoding(unicode) -> "t";
+print_encoding(latin1) -> "".
+
+print_strings(false) -> "l";
+print_strings(true) -> "".
+
+collect([$~|Fmt0], Args0) ->
+    {C,Fmt1,Args1} = collect_cseq(Fmt0, Args0),
+    [C|collect(Fmt1, Args1)];
+collect([C|Fmt], Args) ->
+    [C|collect(Fmt, Args)];
+collect([], []) -> [].
+
+collect_cseq(Fmt0, Args0) ->
+    {F,Ad,Fmt1,Args1} = field_width(Fmt0, Args0),
+    {P,Fmt2,Args2} = precision(Fmt1, Args1),
+    {Pad,Fmt3,Args3} = pad_char(Fmt2, Args2),
+    {Encoding,Fmt4,Args4} = encoding(Fmt3, Args3),
+    {Strings,Fmt5,Args5} = strings(Fmt4, Args4),
+    {C,As,Fmt6,Args6} = collect_cc(Fmt5, Args5),
+    FormatSpec = #{control_char => C, args => As, width => F, adjust => Ad,
+                   precision => P, pad_char => Pad, encoding => Encoding,
+                   strings => Strings},
+    {FormatSpec,Fmt6,Args6}.
+
+encoding([$t|Fmt],Args) ->
+    true = hd(Fmt) =/= $l,
+    {unicode,Fmt,Args};
+encoding(Fmt,Args) ->
+    {latin1,Fmt,Args}.
+
+strings([$l|Fmt],Args) ->
+    true = hd(Fmt) =/= $t,
+    {false,Fmt,Args};
+strings(Fmt,Args) ->
+    {true,Fmt,Args}.
+
+field_width([$-|Fmt0], Args0) ->
+    {F,Fmt,Args} = field_value(Fmt0, Args0),
+    field_width(-F, Fmt, Args);
+field_width(Fmt0, Args0) ->
+    {F,Fmt,Args} = field_value(Fmt0, Args0),
+    field_width(F, Fmt, Args).
+
+field_width(F, Fmt, Args) when F < 0 ->
+    {-F,left,Fmt,Args};
+field_width(F, Fmt, Args) when F >= 0 ->
+    {F,right,Fmt,Args}.
+
+precision([$.|Fmt], Args) ->
+    field_value(Fmt, Args);
+precision(Fmt, Args) ->
+    {none,Fmt,Args}.
+
+field_value([$*|Fmt], [A|Args]) when is_integer(A) ->
+    {A,Fmt,Args};
+field_value([C|Fmt], Args) when is_integer(C), C >= $0, C =< $9 ->
+    field_value([C|Fmt], Args, 0);
+field_value(Fmt, Args) ->
+    {none,Fmt,Args}.
+
+field_value([C|Fmt], Args, F) when is_integer(C), C >= $0, C =< $9 ->
+    field_value(Fmt, Args, 10*F + (C - $0));
+field_value(Fmt, Args, F) ->		%Default case
+    {F,Fmt,Args}.
+
+pad_char([$.,$*|Fmt], [Pad|Args]) -> {Pad,Fmt,Args};
+pad_char([$.,Pad|Fmt], Args) -> {Pad,Fmt,Args};
+pad_char(Fmt, Args) -> {$\s,Fmt,Args}.
+
+%% collect_cc([FormatChar], [Argument]) ->
+%%	{Control,[ControlArg],[FormatChar],[Arg]}.
+%%  Here we collect the argments for each control character.
+%%  Be explicit to cause failure early.
+
+collect_cc([$w|Fmt], [A|Args]) -> {$w,[A],Fmt,Args};
+collect_cc([$p|Fmt], [A|Args]) -> {$p,[A],Fmt,Args};
+collect_cc([$W|Fmt], [A,Depth|Args]) -> {$W,[A,Depth],Fmt,Args};
+collect_cc([$P|Fmt], [A,Depth|Args]) -> {$P,[A,Depth],Fmt,Args};
+collect_cc([$s|Fmt], [A|Args]) -> {$s,[A],Fmt,Args};
+collect_cc([$e|Fmt], [A|Args]) -> {$e,[A],Fmt,Args};
+collect_cc([$f|Fmt], [A|Args]) -> {$f,[A],Fmt,Args};
+collect_cc([$g|Fmt], [A|Args]) -> {$g,[A],Fmt,Args};
+collect_cc([$b|Fmt], [A|Args]) -> {$b,[A],Fmt,Args};
+collect_cc([$B|Fmt], [A|Args]) -> {$B,[A],Fmt,Args};
+collect_cc([$x|Fmt], [A,Prefix|Args]) -> {$x,[A,Prefix],Fmt,Args};
+collect_cc([$X|Fmt], [A,Prefix|Args]) -> {$X,[A,Prefix],Fmt,Args};
+collect_cc([$+|Fmt], [A|Args]) -> {$+,[A],Fmt,Args};
+collect_cc([$#|Fmt], [A|Args]) -> {$#,[A],Fmt,Args};
+collect_cc([$c|Fmt], [A|Args]) -> {$c,[A],Fmt,Args};
+collect_cc([$~|Fmt], Args) when is_list(Args) -> {$~,[],Fmt,Args};
+collect_cc([$n|Fmt], Args) when is_list(Args) -> {$n,[],Fmt,Args};
+collect_cc([$i|Fmt], [A|Args]) -> {$i,[A],Fmt,Args}.
+
+%% pcount([ControlC]) -> Count.
+%%  Count the number of print requests.
+
+pcount(Cs) -> pcount(Cs, 0).
+
+pcount([#{control_char := $p}|Cs], Acc) -> pcount(Cs, Acc+1);
+pcount([#{control_char := $P}|Cs], Acc) -> pcount(Cs, Acc+1);
+pcount([_|Cs], Acc) -> pcount(Cs, Acc);
+pcount([], Acc) -> Acc.
+
+%% build([Control], Pc, Indentation) -> eFmt:chars().
+%%  Interpret the control structures. Count the number of print
+%%  remaining and only calculate indentation when necessary. Must also
+%%  be smart when calculating indentation for characters in format.
+
+build([#{control_char := C, args := As, width := F, adjust := Ad,
+         precision := P, pad_char := Pad, encoding := Enc,
+         strings := Str} | Cs], Pc0, I) ->
+    S = control(C, As, F, Ad, P, Pad, Enc, Str, I),
+    Pc1 = decr_pc(C, Pc0),
+    if
+	Pc1 > 0 -> [S|build(Cs, Pc1, indentation(S, I))];
+	true -> [S|build(Cs, Pc1, I)]
+    end;
+build([$\n|Cs], Pc, _I) -> [$\n|build(Cs, Pc, 0)];
+build([$\t|Cs], Pc, I) -> [$\t|build(Cs, Pc, ((I + 8) div 8) * 8)];
+build([C|Cs], Pc, I) -> [C|build(Cs, Pc, I+1)];
+build([], _Pc, _I) -> [].
+
+decr_pc($p, Pc) -> Pc - 1;
+decr_pc($P, Pc) -> Pc - 1;
+decr_pc(_, Pc) -> Pc.
+
+
+%%  Calculate the indentation of the end of a string given its start
+%%  indentation. We assume tabs at 8 cols.
+
+-spec indentation(String, StartIndent) -> integer() when
+      String :: eFmt:chars(),
+      StartIndent :: integer().
+
+indentation([$\n|Cs], _I) -> indentation(Cs, 0);
+indentation([$\t|Cs], I) -> indentation(Cs, ((I + 8) div 8) * 8);
+indentation([C|Cs], I) when is_integer(C) ->
+    indentation(Cs, I+1);
+indentation([C|Cs], I) ->
+    indentation(Cs, indentation(C, I));
+indentation([], I) -> I.
+
+%% control(FormatChar, [Argument], FieldWidth, Adjust, Precision, PadChar,
+%%	   Encoding, Indentation) -> String
+%%  This is the main dispatch function for the various formatting commands.
+%%  Field widths and precisions have already been calculated.
+
+control($w, [A], F, Adj, P, Pad, Enc, _Str, _I) ->
+    term(eFmt:write(A, [{depth,-1}, {encoding, Enc}]), F, Adj, P, Pad);
+control($p, [A], F, Adj, P, Pad, Enc, Str, I) ->
+    print(A, -1, F, Adj, P, Pad, Enc, Str, I);
+control($W, [A,Depth], F, Adj, P, Pad, Enc, _Str, _I) when is_integer(Depth) ->
+    term(eFmt:write(A, [{depth,Depth}, {encoding, Enc}]), F, Adj, P, Pad);
+control($P, [A,Depth], F, Adj, P, Pad, Enc, Str, I) when is_integer(Depth) ->
+    print(A, Depth, F, Adj, P, Pad, Enc, Str, I);
+control($s, [A], F, Adj, P, Pad, latin1, _Str, _I) when is_atom(A) ->
+    L = iolist_to_chars(atom_to_list(A)),
+    string(L, F, Adj, P, Pad);
+control($s, [A], F, Adj, P, Pad, unicode, _Str, _I) when is_atom(A) ->
+    string(atom_to_list(A), F, Adj, P, Pad);
+control($s, [L0], F, Adj, P, Pad, latin1, _Str, _I) ->
+    L = iolist_to_chars(L0),
+    string(L, F, Adj, P, Pad);
+control($s, [L0], F, Adj, P, Pad, unicode, _Str, _I) ->
+    L = cdata_to_chars(L0),
+    uniconv(string(L, F, Adj, P, Pad));
+control($e, [A], F, Adj, P, Pad, _Enc, _Str, _I) when is_float(A) ->
+    fwrite_e(A, F, Adj, P, Pad);
+control($f, [A], F, Adj, P, Pad, _Enc, _Str, _I) when is_float(A) ->
+    fwrite_f(A, F, Adj, P, Pad);
+control($g, [A], F, Adj, P, Pad, _Enc, _Str, _I) when is_float(A) ->
+    fwrite_g(A, F, Adj, P, Pad);
+control($b, [A], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A) ->
+    unprefixed_integer(A, F, Adj, base(P), Pad, true);
+control($B, [A], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A) ->
+    unprefixed_integer(A, F, Adj, base(P), Pad, false);
+control($x, [A,Prefix], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A),
+                                                 is_atom(Prefix) ->
+    prefixed_integer(A, F, Adj, base(P), Pad, atom_to_list(Prefix), true);
+control($x, [A,Prefix], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A) ->
+    true = eFmt:deep_char_list(Prefix), %Check if Prefix a character list
+    prefixed_integer(A, F, Adj, base(P), Pad, Prefix, true);
+control($X, [A,Prefix], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A),
+                                                 is_atom(Prefix) ->
+    prefixed_integer(A, F, Adj, base(P), Pad, atom_to_list(Prefix), false);
+control($X, [A,Prefix], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A) ->
+    true = eFmt:deep_char_list(Prefix), %Check if Prefix a character list
+    prefixed_integer(A, F, Adj, base(P), Pad, Prefix, false);
+control($+, [A], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A) ->
+    Base = base(P),
+    Prefix = [integer_to_list(Base), $#],
+    prefixed_integer(A, F, Adj, Base, Pad, Prefix, true);
+control($#, [A], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A) ->
+    Base = base(P),
+    Prefix = [integer_to_list(Base), $#],
+    prefixed_integer(A, F, Adj, Base, Pad, Prefix, false);
+control($c, [A], F, Adj, P, Pad, unicode, _Str, _I) when is_integer(A) ->
+    char(A, F, Adj, P, Pad);
+control($c, [A], F, Adj, P, Pad, _Enc, _Str, _I) when is_integer(A) ->
+    char(A band 255, F, Adj, P, Pad);
+control($~, [], F, Adj, P, Pad, _Enc, _Str, _I) -> char($~, F, Adj, P, Pad);
+control($n, [], F, Adj, P, Pad, _Enc, _Str, _I) -> newline(F, Adj, P, Pad);
+control($i, [_A], _F, _Adj, _P, _Pad, _Enc, _Str, _I) -> [].
+
+-ifdef(UNICODE_AS_BINARIES).
+uniconv(C) ->
+    unicode:characters_to_binary(C,unicode).
+-else.
+uniconv(C) ->
+    C.
+-endif.
+%% Default integer base
+base(none) ->
+    10;
+base(B) when is_integer(B) ->
+    B.
+
+%% term(TermList, Field, Adjust, Precision, PadChar)
+%%  Output the characters in a term.
+%%  Adjust the characters within the field if length less than Max padding
+%%  with PadChar.
+
+term(T, none, _Adj, none, _Pad) -> T;
+term(T, none, Adj, P, Pad) -> term(T, P, Adj, P, Pad);
+term(T, F, Adj, P0, Pad) ->
+    L = lists:flatlength(T),
+    P = erlang:min(L, case P0 of none -> F; _ -> min(P0, F) end),
+    if
+	L > P ->
+	    adjust(chars($*, P), chars(Pad, F-P), Adj);
+	F >= P ->
+	    adjust(T, chars(Pad, F-L), Adj)
+    end.
+
+%% print(Term, Depth, Field, Adjust, Precision, PadChar, Encoding,
+%%       Indentation)
+%% Print a term. Field width sets maximum line length, Precision sets
+%% initial indentation.
+
+print(T, D, none, Adj, P, Pad, E, Str, I) ->
+    print(T, D, 80, Adj, P, Pad, E, Str, I);
+print(T, D, F, Adj, none, Pad, E, Str, I) ->
+    print(T, D, F, Adj, I+1, Pad, E, Str, I);
+print(T, D, F, right, P, _Pad, Enc, Str, _I) ->
+    Options = [{column, P},
+               {line_length, F},
+               {depth, D},
+               {encoding, Enc},
+               {strings, Str}],
+    io_lib_pretty:print(T, Options).
+
+%% fwrite_e(Float, Field, Adjust, Precision, PadChar)
+
+fwrite_e(Fl, none, Adj, none, Pad) ->		%Default values
+    fwrite_e(Fl, none, Adj, 6, Pad);
+fwrite_e(Fl, none, _Adj, P, _Pad) when P >= 2 ->
+    float_e(Fl, float_data(Fl), P);
+fwrite_e(Fl, F, Adj, none, Pad) ->
+    fwrite_e(Fl, F, Adj, 6, Pad);
+fwrite_e(Fl, F, Adj, P, Pad) when P >= 2 ->
+    term(float_e(Fl, float_data(Fl), P), F, Adj, F, Pad).
+
+float_e(Fl, Fd, P) when Fl < 0.0 ->		%Negative numbers
+    [$-|float_e(-Fl, Fd, P)];
+float_e(_Fl, {Ds,E}, P) ->
+    case float_man(Ds, 1, P-1) of
+	{[$0|Fs],true} -> [[$1|Fs]|float_exp(E)];
+	{Fs,false} -> [Fs|float_exp(E-1)]
+    end.
+
+%% float_man([Digit], Icount, Dcount) -> {[Chars],CarryFlag}.
+%%  Generate the characters in the mantissa from the digits with Icount
+%%  characters before the '.' and Dcount decimals. Handle carry and let
+%%  caller decide what to do at top.
+
+float_man(Ds, 0, Dc) ->
+    {Cs,C} = float_man(Ds, Dc),
+    {[$.|Cs],C};
+float_man([D|Ds], I, Dc) ->
+    case float_man(Ds, I-1, Dc) of
+	{Cs,true} when D =:= $9 -> {[$0|Cs],true};
+	{Cs,true} -> {[D+1|Cs],false};
+	{Cs,false} -> {[D|Cs],false}
+    end;
+float_man([], I, Dc) ->				%Pad with 0's
+    {string:chars($0, I, [$.|string:chars($0, Dc)]),false}.
+
+float_man([D|_], 0) when D >= $5 -> {[],true};
+float_man([_|_], 0) -> {[],false};
+float_man([D|Ds], Dc) ->
+    case float_man(Ds, Dc-1) of
+	{Cs,true} when D =:= $9 -> {[$0|Cs],true};
+	{Cs,true} -> {[D+1|Cs],false}; 
+	{Cs,false} -> {[D|Cs],false}
+    end;
+float_man([], Dc) -> {string:chars($0, Dc),false}.	%Pad with 0's
+
+%% float_exp(Exponent) -> [Char].
+%%  Generate the exponent of a floating point number. Always include sign.
+
+float_exp(E) when E >= 0 ->
+    [$e,$+|integer_to_list(E)];
+float_exp(E) ->
+    [$e|integer_to_list(E)].
+
+%% fwrite_f(FloatData, Field, Adjust, Precision, PadChar)
+
+fwrite_f(Fl, none, Adj, none, Pad) ->		%Default values
+    fwrite_f(Fl, none, Adj, 6, Pad);
+fwrite_f(Fl, none, _Adj, P, _Pad) when P >= 1 ->
+    float_f(Fl, float_data(Fl), P);
+fwrite_f(Fl, F, Adj, none, Pad) ->
+    fwrite_f(Fl, F, Adj, 6, Pad);
+fwrite_f(Fl, F, Adj, P, Pad) when P >= 1 ->
+    term(float_f(Fl, float_data(Fl), P), F, Adj, F, Pad).
+
+float_f(Fl, Fd, P) when Fl < 0.0 ->
+    [$-|float_f(-Fl, Fd, P)];
+float_f(Fl, {Ds,E}, P) when E =< 0 ->
+    float_f(Fl, {string:chars($0, -E+1, Ds),1}, P);	%Prepend enough 0's
+float_f(_Fl, {Ds,E}, P) ->
+    case float_man(Ds, E, P) of
+	{Fs,true} -> "1" ++ Fs;			%Handle carry
+	{Fs,false} -> Fs
+    end.
+
+%% float_data([FloatChar]) -> {[Digit],Exponent}
+
+float_data(Fl) ->
+    float_data(float_to_list(Fl), []).
+
+float_data([$e|E], Ds) ->
+    {lists:reverse(Ds),list_to_integer(E)+1};
+float_data([D|Cs], Ds) when D >= $0, D =< $9 ->
+    float_data(Cs, [D|Ds]);
+float_data([_|Cs], Ds) ->
+    float_data(Cs, Ds).
+
+%%  Writes the shortest, correctly rounded string that converts
+%%  to Float when read back with list_to_float/1.
+%%
+%%  See also "Printing Floating-Point Numbers Quickly and Accurately"
+%%  in Proceedings of the SIGPLAN '96 Conference on Programming
+%%  Language Design and Implementation.
+
+-spec fwrite_g(float()) -> string().
+
+fwrite_g(0.0) ->
+    "0.0";
+fwrite_g(Float) when is_float(Float) ->
+    {Frac, Exp} = mantissa_exponent(Float),
+    {Place, Digits} = fwrite_g_1(Float, Exp, Frac),
+    R = insert_decimal(Place, [$0 + D || D <- Digits]),
+    [$- || true <- [Float < 0.0]] ++ R.
+
+-define(BIG_POW, (1 bsl 52)).
+-define(MIN_EXP, (-1074)).
+
+mantissa_exponent(F) ->
+    case <<F:64/float>> of
+        <<_S:1, 0:11, M:52>> -> % denormalized
+            E = log2floor(M),
+            {M bsl (53 - E), E - 52 - 1075};
+        <<_S:1, BE:11, M:52>> when BE < 2047 ->
+            {M + ?BIG_POW, BE - 1075}
+    end.
+
+fwrite_g_1(Float, Exp, Frac) ->
+    Round = (Frac band 1) =:= 0,
+    if 
+        Exp >= 0  ->
+            BExp = 1 bsl Exp,
+            if
+                Frac =:= ?BIG_POW ->
+                    scale(Frac * BExp * 4, 4, BExp * 2, BExp,
+                          Round, Round, Float);
+                true ->
+                    scale(Frac * BExp * 2, 2, BExp, BExp,
+                          Round, Round, Float)
+            end;
+        Exp < ?MIN_EXP ->
+            BExp = 1 bsl (?MIN_EXP - Exp),
+            scale(Frac * 2, 1 bsl (1 - Exp), BExp, BExp,
+                  Round, Round, Float);
+        Exp > ?MIN_EXP, Frac =:= ?BIG_POW ->
+            scale(Frac * 4, 1 bsl (2 - Exp), 2, 1,
+                  Round, Round, Float);
+        true ->
+            scale(Frac * 2, 1 bsl (1 - Exp), 1, 1,
+                  Round, Round, Float)
+    end.
+
+scale(R, S, MPlus, MMinus, LowOk, HighOk, Float) ->
+    Est = int_ceil(math:log10(abs(Float)) - 1.0e-10),
+    %% Note that the scheme implementation uses a 326 element look-up
+    %% table for int_pow(10, N) where we do not.
+    if
+        Est >= 0 ->
+            fixup(R, S * int_pow(10, Est), MPlus, MMinus, Est,
+                  LowOk, HighOk);
+        true ->
+            Scale = int_pow(10, -Est),
+            fixup(R * Scale, S, MPlus * Scale, MMinus * Scale, Est,
+                  LowOk, HighOk)
+    end.
+
+fixup(R, S, MPlus, MMinus, K, LowOk, HighOk) ->
+    TooLow = if 
+                 HighOk ->  R + MPlus >= S;
+                 true -> R + MPlus > S
+             end,
+    case TooLow of
+        true ->
+            {K + 1, generate(R, S, MPlus, MMinus, LowOk, HighOk)};
+        false ->
+            {K, generate(R * 10, S, MPlus * 10, MMinus * 10, LowOk, HighOk)}
+    end.
+
+generate(R0, S, MPlus, MMinus, LowOk, HighOk) ->
+    D = R0 div S,
+    R = R0 rem S,
+    TC1 = if
+              LowOk -> R =< MMinus;
+              true -> R < MMinus
+          end,
+    TC2 = if
+              HighOk -> R + MPlus >= S;
+              true -> R + MPlus > S
+          end,
+    case {TC1, TC2} of
+        {false, false} -> 
+            [D | generate(R * 10, S, MPlus * 10, MMinus * 10, LowOk, HighOk)];
+        {false, true} ->
+            [D + 1];
+        {true, false} -> 
+            [D];
+        {true, true} when R * 2 < S ->
+            [D];
+        {true, true} ->
+            [D + 1]
+    end.
+
+insert_decimal(0, S) ->
+    "0." ++ S;
+insert_decimal(Place, S) ->
+    L = length(S),
+    if
+        Place < 0;
+        Place >= L ->
+            ExpL = integer_to_list(Place - 1),
+            ExpDot = if L =:= 1 -> 2; true -> 1 end,
+            ExpCost = length(ExpL) + 1 + ExpDot,
+            if 
+                Place < 0 ->
+                    if 
+                        2 - Place =< ExpCost ->
+                            "0." ++ lists:duplicate(-Place, $0) ++ S;
+                        true ->
+                            insert_exp(ExpL, S)
+                    end;
+                true ->
+                    if
+                        Place - L + 2 =< ExpCost ->
+                            S ++ lists:duplicate(Place - L, $0) ++ ".0";
+                        true ->
+                            insert_exp(ExpL, S)
+                    end
+            end;
+        true ->
+            {S0, S1} = lists:split(Place, S),
+            S0 ++ "." ++ S1
+    end.
+
+insert_exp(ExpL, [C]) ->
+    [C] ++ ".0e" ++ ExpL;
+insert_exp(ExpL, [C | S]) ->
+    [C] ++ "." ++ S ++ "e" ++ ExpL.
+
+int_ceil(X) when is_float(X) ->
+    T = trunc(X),
+    case (X - T) of
+        Neg when Neg < 0 -> T;
+        Pos when Pos > 0 -> T + 1;
+        _ -> T
+    end.
+
+int_pow(X, 0) when is_integer(X) ->
+    1;
+int_pow(X, N) when is_integer(X), is_integer(N), N > 0 ->
+    int_pow(X, N, 1).
+
+int_pow(X, N, R) when N < 2 ->
+    R * X;
+int_pow(X, N, R) ->
+    int_pow(X * X, N bsr 1, case N band 1 of 1 -> R * X; 0 -> R end).
+
+log2floor(Int) when is_integer(Int), Int > 0 ->
+    log2floor(Int, 0).
+
+log2floor(0, N) ->
+    N;
+log2floor(Int, N) ->
+    log2floor(Int bsr 1, 1 + N).
+
+%% fwrite_g(Float, Field, Adjust, Precision, PadChar)
+%%  Use the f form if Float is >= 0.1 and < 1.0e4, 
+%%  and the prints correctly in the f form, else the e form.
+%%  Precision always means the # of significant digits.
+
+fwrite_g(Fl, F, Adj, none, Pad) ->
+    fwrite_g(Fl, F, Adj, 6, Pad);
+fwrite_g(Fl, F, Adj, P, Pad) when P >= 1 ->
+    A = abs(Fl),
+    E = if A < 1.0e-1 -> -2;
+	   A < 1.0e0  -> -1;
+	   A < 1.0e1  -> 0;
+	   A < 1.0e2  -> 1;
+	   A < 1.0e3  -> 2;
+	   A < 1.0e4  -> 3;
+	   true       -> fwrite_f
+	end,
+    if  P =< 1, E =:= -1;
+	P-1 > E, E >= -1 ->
+	    fwrite_f(Fl, F, Adj, P-1-E, Pad);
+	P =< 1 ->
+	    fwrite_e(Fl, F, Adj, 2, Pad);
+	true ->
+	    fwrite_e(Fl, F, Adj, P, Pad)
+    end.
+
+
+%% iolist_to_chars(iolist()) -> deep_char_list()
+
+iolist_to_chars([C|Cs]) when is_integer(C), C >= $\000, C =< $\377 ->
+    [C | iolist_to_chars(Cs)];
+iolist_to_chars([I|Cs]) ->
+    [iolist_to_chars(I) | iolist_to_chars(Cs)];
+iolist_to_chars([]) ->
+    [];
+iolist_to_chars(B) when is_binary(B) ->
+    binary_to_list(B).
+
+%% cdata() :: clist() | cbinary()
+%% clist() ::  maybe_improper_list(char() | cbinary() | clist(),
+%%                                 cbinary() | nil())
+%% cbinary() :: unicode:unicode_binary() | unicode:latin1_binary()
+
+%% cdata_to_chars(cdata()) -> eFmt:deep_char_list()
+
+cdata_to_chars([C|Cs]) when is_integer(C), C >= $\000 ->
+    [C | cdata_to_chars(Cs)];
+cdata_to_chars([I|Cs]) ->
+    [cdata_to_chars(I) | cdata_to_chars(Cs)];
+cdata_to_chars([]) ->
+    [];
+cdata_to_chars(B) when is_binary(B) ->
+    case catch unicode:characters_to_list(B) of
+        L when is_list(L) -> L;
+        _ -> binary_to_list(B)
+    end.
+
+%% string(String, Field, Adjust, Precision, PadChar)
+
+string(S, none, _Adj, none, _Pad) -> S;
+string(S, F, Adj, none, Pad) ->
+    string_field(S, F, Adj, lists:flatlength(S), Pad);
+string(S, none, _Adj, P, Pad) ->
+    string_field(S, P, left, lists:flatlength(S), Pad);
+string(S, F, Adj, P, Pad) when F >= P ->
+    N = lists:flatlength(S),
+    if F > P ->
+	    if N > P ->
+		    adjust(flat_trunc(S, P), chars(Pad, F-P), Adj);
+	       N < P ->
+		    adjust([S|chars(Pad, P-N)], chars(Pad, F-P), Adj);
+	       true -> % N == P
+		    adjust(S, chars(Pad, F-P), Adj)
+	    end;
+       true -> % F == P
+	    string_field(S, F, Adj, N, Pad)
+    end.
+
+string_field(S, F, _Adj, N, _Pad) when N > F ->
+    flat_trunc(S, F);
+string_field(S, F, Adj, N, Pad) when N < F ->
+    adjust(S, chars(Pad, F-N), Adj);
+string_field(S, _, _, _, _) -> % N == F
+    S.
+
+%% unprefixed_integer(Int, Field, Adjust, Base, PadChar, Lowercase)
+%% -> [Char].
+
+unprefixed_integer(Int, F, Adj, Base, Pad, Lowercase)
+  when Base >= 2, Base =< 1+$Z-$A+10 ->
+    if Int < 0 ->
+	    S = cond_lowercase(erlang:integer_to_list(-Int, Base), Lowercase),
+	    term([$-|S], F, Adj, none, Pad);
+       true ->
+	    S = cond_lowercase(erlang:integer_to_list(Int, Base), Lowercase),
+	    term(S, F, Adj, none, Pad)
+    end.
+
+%% prefixed_integer(Int, Field, Adjust, Base, PadChar, Prefix, Lowercase)
+%% -> [Char].
+
+prefixed_integer(Int, F, Adj, Base, Pad, Prefix, Lowercase)
+  when Base >= 2, Base =< 1+$Z-$A+10 ->
+    if Int < 0 ->
+	    S = cond_lowercase(erlang:integer_to_list(-Int, Base), Lowercase),
+	    term([$-,Prefix|S], F, Adj, none, Pad);
+       true ->
+	    S = cond_lowercase(erlang:integer_to_list(Int, Base), Lowercase),
+	    term([Prefix|S], F, Adj, none, Pad)
+    end.
+
+%% char(Char, Field, Adjust, Precision, PadChar) -> chars().
+
+char(C, none, _Adj, none, _Pad) -> [C];
+char(C, F, _Adj, none, _Pad) -> chars(C, F);
+char(C, none, _Adj, P, _Pad) -> chars(C, P);
+char(C, F, Adj, P, Pad) when F >= P ->
+    adjust(chars(C, P), chars(Pad, F - P), Adj).
+
+%% newline(Field, Adjust, Precision, PadChar) -> [Char].
+
+newline(none, _Adj, _P, _Pad) -> "\n";
+newline(F, right, _P, _Pad) -> chars($\n, F).
+
+%%
+%% Utilities
+%%
+
+adjust(Data, [], _) -> Data;
+adjust(Data, Pad, left) -> [Data|Pad];
+adjust(Data, Pad, right) -> [Pad|Data].
+
+%% Flatten and truncate a deep list to at most N elements.
+
+flat_trunc(List, N) when is_integer(N), N >= 0 ->
+    flat_trunc(List, N, [], []).
+
+flat_trunc(L, 0, _, R) when is_list(L) ->
+    lists:reverse(R);
+flat_trunc([H|T], N, S, R) when is_list(H) ->
+    flat_trunc(H, N, [T|S], R);
+flat_trunc([H|T], N, S, R) ->
+    flat_trunc(T, N-1, S, [H|R]);
+flat_trunc([], N, [H|S], R) ->
+    flat_trunc(H, N, S, R);
+flat_trunc([], _, [], R) ->
+    lists:reverse(R).
+
+%% A deep version of string:chars/2,3
+
+chars(_C, 0) ->
+    [];
+chars(C, 1) ->
+    [C];
+chars(C, 2) ->
+    [C,C];
+chars(C, 3) ->
+    [C,C,C];
+chars(C, N) when is_integer(N), (N band 1) =:= 0 ->
+    S = chars(C, N bsr 1),
+    [S|S];
+chars(C, N) when is_integer(N) ->
+    S = chars(C, N bsr 1),
+    [C,S|S].
+
+%chars(C, N, Tail) ->
+%    [chars(C, N)|Tail].
+
+%% Lowercase conversion
+
+cond_lowercase(String, true) ->
+    lowercase(String);
+cond_lowercase(String,false) ->
+    String.
+
+lowercase([H|T]) when is_integer(H), H >= $A, H =< $Z ->
+    [(H-$A+$a)|lowercase(T)];
+lowercase([H|T]) ->
+    [H|lowercase(T)];
+lowercase([]) ->
+    [].