diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100755
index 0000000..5de6fc8
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,59 @@
+cmake_minimum_required(VERSION 3.9)
+project(tg2sip)
+
+set(CMAKE_CXX_STANDARD 17)
+
+add_subdirectory(libtgvoip)
+
+find_package(PkgConfig REQUIRED)
+find_package(Threads REQUIRED)
+find_package(Td 1.2.0 REQUIRED)
+find_package(spdlog 0.17 REQUIRED)
+pkg_check_modules(PJSIP libpjproject>=2.8 REQUIRED)
+pkg_check_modules(OPUS opus REQUIRED)
+
+add_executable(tg2sip
+        tg2sip/main.cpp
+        tg2sip/tg.cpp
+        tg2sip/tg.h
+        tg2sip/sip.cpp
+        tg2sip/sip.h
+        tg2sip/settings.cpp
+        tg2sip/settings.h
+        tg2sip/logging.cpp
+        tg2sip/logging.h
+        tg2sip/utils.cpp
+        tg2sip/utils.h
+        tg2sip/queue.h
+        tg2sip/gateway.cpp
+        tg2sip/gateway.h
+        )
+
+add_custom_command(
+        TARGET tg2sip PRE_BUILD
+        COMMAND ${CMAKE_COMMAND} -E copy
+        ${CMAKE_SOURCE_DIR}/settings.ini
+        $<TARGET_FILE_DIR:tg2sip>)
+
+target_include_directories(tg2sip PRIVATE
+        ${PJSIP_INCLUDE_DIRS}
+        ${PROJECT_SOURCE_DIR}
+        ${OPUS_INCLUDE_DIRS}
+        include)
+
+target_link_libraries(tg2sip PRIVATE
+        ${PJSIP_LIBRARIES}
+        libtgvoip
+        Threads::Threads
+        Td::TdStatic)
+
+add_executable(gen_db
+        tg2sip/gen_db.cpp
+        tg2sip/settings.cpp
+        tg2sip/settings.h)
+
+target_include_directories(gen_db PRIVATE
+        include)
+
+target_link_libraries(gen_db PRIVATE
+        Td::TdStatic)
\ No newline at end of file
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..d159169
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    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.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
diff --git a/Dockerfile b/Dockerfile
new file mode 100755
index 0000000..4684323
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,69 @@
+FROM ubuntu:bionic as builder
+
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+		build-essential git \
+		wget ca-certificates \
+		pkg-config libopus-dev libssl-dev \
+		zlib1g-dev gperf ccache \
+	&& rm -rf /var/lib/apt/lists/*
+
+RUN wget https://cmake.org/files/v3.9/cmake-3.9.6-Linux-x86_64.sh \
+    && sh cmake-3.9.6-Linux-x86_64.sh --prefix=/usr --exclude-subdir
+
+COPY tdlib_header.patch /
+
+RUN git clone https://github.com/tdlib/td.git \
+    && cd td \
+    && git checkout cfe4d9bdcee9305632eb228a46a95407d05b5c7a -b build \
+    && git apply /tdlib_header.patch \
+    && mkdir build \
+    && cd build \
+    && cmake -DCMAKE_BUILD_TYPE=Release .. \
+    && cmake --build . --target install
+
+COPY config_site.h /
+COPY pj_threadname.patch /
+COPY pj_cpp1z.patch /
+
+RUN git clone https://github.com/pjsip/pjproject.git \
+    && cd pjproject \
+    && git reset --hard 2.8 \
+    && git apply /pj_threadname.patch \
+    && git apply /pj_cpp1z.patch \
+    && cp /config_site.h pjlib/include/pj \
+    && ./configure --disable-sound CFLAGS="-O3 -DNDEBUG" \
+    && make dep \
+    && make -j $(shell nproc) \
+    && make install
+
+RUN git clone -n https://github.com/gabime/spdlog.git \
+    && cd spdlog \
+    && git checkout tags/v0.17.0 \
+    && mkdir build \
+    && cd build \
+    && cmake -DCMAKE_BUILD_TYPE=Release -DSPDLOG_BUILD_EXAMPLES=OFF -DSPDLOG_BUILD_TESTING=OFF .. \
+    && cmake --build . --target install
+
+COPY . /src
+
+RUN cd src \
+    && mkdir build \
+    && cd build \
+    && cmake -DCMAKE_BUILD_TYPE=Release .. \
+    && cmake --build .
+
+FROM ubuntu:bionic
+
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+		libopus0 \
+	&& rm -rf /var/lib/apt/lists/*
+
+WORKDIR /gateway
+
+COPY --from=builder /src/build/tg2sip .
+COPY --from=builder /src/build/gen_db .
+COPY --from=builder /src/build/settings.ini .
+
+CMD ./tg2sip
diff --git a/README.md b/README.md
index e69de29..4d8df38 100644
--- a/README.md
+++ b/README.md
@@ -0,0 +1,27 @@
+# TG2SIP
+
+TG2SIP is a Telegram<->SIP voice gateway. It can be used to forward incoming telegram calls to your SIP PBX or make SIP->Telegram calls.
+
+## Requirements
+
+Your SIP PBX should be comaptible with `L16@48000` or `OPUS@48000` voice codec.
+
+## Usage
+
+1. Download prebuild version from CI or compile it yourself.
+2. Obtain `api_id` and `api_hash` tokens from [this](https://my.telegram.org) page and put them in `settings.ini` file.
+3. Login into telegram with `gen_db` app
+4. Set SIP server settings in `settings.ini`
+5. Run `tg2sip`
+
+## Donate
+
+[![paypal](https://www.paypalobjects.com/en_US/i/btn/btn_donateCC_LG.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=755FZWPRC9YGL&lc=US&item_name=TG2SIP&currency_code=USD&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted)
+
+[Yandex.Money](https://yasobe.ru/na/tg2sip)
+
+**BTC** 39wNzvtcyRrTKmq5DjcUfGTixnGVSf8qLg  
+**BCH** qqgwg0g96sayht4lzxc89ky7mkdxfyj7jcl5m8qfps  
+**ETH** 0x72B8cb476b2c85b1170Ae2cdFB243B17680290b4  
+**ETC** 0x9C7d6CD9F9E0584e65f8aD20e1d2Ced947a55207  
+**LTC** MFyBRJTnHqXharzH7D3FYeEhAJuywMRfMd  
diff --git a/buildenv/Dockerfile b/buildenv/Dockerfile
new file mode 100644
index 0000000..68d5127
--- /dev/null
+++ b/buildenv/Dockerfile
@@ -0,0 +1,47 @@
+FROM ubuntu:bionic
+
+RUN apt-get update \
+	&& apt-get install -y --no-install-recommends \
+		build-essential git \
+		wget ca-certificates \
+		pkg-config libopus-dev libssl-dev \
+		zlib1g-dev gperf ccache \
+	&& rm -rf /var/lib/apt/lists/*
+
+RUN wget https://cmake.org/files/v3.9/cmake-3.9.6-Linux-x86_64.sh \
+    && sh cmake-3.9.6-Linux-x86_64.sh --prefix=/usr --exclude-subdir
+
+COPY tdlib_header.patch /
+COPY tdlib_threadname.patch /
+
+RUN git clone https://github.com/tdlib/td.git \
+    && cd td \
+    && git reset --hard v1.2.0 \
+    && git apply /tdlib_header.patch \
+    && git apply /tdlib_threadname.patch \
+    && mkdir build \
+    && cd build \
+    && cmake -DCMAKE_BUILD_TYPE=Release .. \
+    && cmake --build . --target install \
+    && cd / \
+    && rm -rf td
+
+COPY config_site.h /
+
+RUN git clone https://github.com/Infactum/pjproject.git \
+    && cd pjproject \
+    && cp /config_site.h pjlib/include/pj \
+    && ./configure --disable-sound CFLAGS="-O3 -DNDEBUG" \
+    && make dep && make && make install \
+    && cd / \
+    && rm -rf pjproject
+
+RUN git clone -n https://github.com/gabime/spdlog.git \
+    && cd spdlog \
+    && git checkout tags/v0.17.0 \
+    && mkdir build \
+    && cd build \
+    && cmake -DCMAKE_BUILD_TYPE=Release -DSPDLOG_BUILD_EXAMPLES=OFF -DSPDLOG_BUILD_TESTING=OFF .. \
+    && cmake --build . --target install \
+    && cd / \
+    && rm -rf spdlog
\ No newline at end of file
diff --git a/buildenv/config_site.h b/buildenv/config_site.h
new file mode 100755
index 0000000..0802d59
--- /dev/null
+++ b/buildenv/config_site.h
@@ -0,0 +1,8 @@
+#define PJMEDIA_CONF_USE_SWITCH_BOARD 	   1
+#define PJMEDIA_CONF_SWITCH_BOARD_BUF_SIZE 2000
+
+#define PJSUA_MAX_CALLS 	128
+#define PJSUA_MAX_PLAYERS 	256
+#define PJ_IOQUEUE_MAX_HANDLES 	256
+
+#define PJMEDIA_CODEC_L16_HAS_48KHZ_MONO 1
\ No newline at end of file
diff --git a/buildenv/tdlib_header.patch b/buildenv/tdlib_header.patch
new file mode 100644
index 0000000..c79ea26
--- /dev/null
+++ b/buildenv/tdlib_header.patch
@@ -0,0 +1,19 @@
+diff --git a/td/telegram/Td.cpp b/td/telegram/Td.cpp
+index a150e6c..cd66d91 100644
+--- a/td/telegram/Td.cpp
++++ b/td/telegram/Td.cpp
+@@ -4827,10 +4827,10 @@ Status Td::set_parameters(td_api::object_ptr<td_api::tdlibParameters> parameters
+   if (options.application_version.empty()) {
+     return Status::Error(400, "Application version must be non-empty");
+   }
+-  if (options.api_id != 21724) {
+-    options.application_version += ", TDLib ";
+-    options.application_version += TDLIB_VERSION;
+-  }
++  // if (options.api_id != 21724) {
++  //   options.application_version += ", TDLib ";
++  //   options.application_version += TDLIB_VERSION;
++  // }
+   G()->set_mtproto_header(std::make_unique<MtprotoHeader>(options));
+ 
+   state_ = State::Decrypt;
diff --git a/buildenv/tdlib_threadname.patch b/buildenv/tdlib_threadname.patch
new file mode 100644
index 0000000..802dfb5
--- /dev/null
+++ b/buildenv/tdlib_threadname.patch
@@ -0,0 +1,12 @@
+diff --git a/tdutils/td/utils/port/detail/ThreadStl.h b/tdutils/td/utils/port/detail/ThreadStl.h
+index 64bf321..68d3bf6 100644
+--- a/tdutils/td/utils/port/detail/ThreadStl.h
++++ b/tdutils/td/utils/port/detail/ThreadStl.h
+@@ -37,6 +37,7 @@ class ThreadStl {
+       invoke_tuple(std::move(args));
+       clear_thread_locals();
+     });
++    pthread_setname_np(thread_.native_handle(), "tdlib");
+   }
+ 
+   void join() {
diff --git a/include/INIReader.h b/include/INIReader.h
new file mode 100755
index 0000000..68c3dc3
--- /dev/null
+++ b/include/INIReader.h
@@ -0,0 +1,441 @@
+// Read an INI file into easy-to-access name/value pairs.
+
+// inih and INIReader are released under the New BSD license (see LICENSE.txt).
+// Go to the project home page for more info:
+//
+// https://github.com/benhoyt/inih
+/* inih -- simple .INI file parser
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+https://github.com/benhoyt/inih
+
+*/
+
+#ifndef __INI_H__
+#define __INI_H__
+
+/* Make this header file easier to include in C++ code */
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+
+/* Typedef for prototype of handler function. */
+typedef int (*ini_handler)(void* user, const char* section,
+                           const char* name, const char* value);
+
+/* Typedef for prototype of fgets-style reader function. */
+typedef char* (*ini_reader)(char* str, int num, void* stream);
+
+/* Parse given INI-style file. May have [section]s, name=value pairs
+   (whitespace stripped), and comments starting with ';' (semicolon). Section
+   is "" if name=value pair parsed before any section heading. name:value
+   pairs are also supported as a concession to Python's configparser.
+
+   For each name=value pair parsed, call handler function with given user
+   pointer as well as section, name, and value (data only valid for duration
+   of handler call). Handler should return nonzero on success, zero on error.
+
+   Returns 0 on success, line number of first error on parse error (doesn't
+   stop on first error), -1 on file open error, or -2 on memory allocation
+   error (only when INI_USE_STACK is zero).
+*/
+int ini_parse(const char* filename, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
+   close the file when it's finished -- the caller must do that. */
+int ini_parse_file(FILE* file, ini_handler handler, void* user);
+
+/* Same as ini_parse(), but takes an ini_reader function pointer instead of
+   filename. Used for implementing custom or string-based I/O. */
+int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+                     void* user);
+
+/* Nonzero to allow multi-line value parsing, in the style of Python's
+   configparser. If allowed, ini_parse() will call the handler with the same
+   name for each subsequent line parsed. */
+#ifndef INI_ALLOW_MULTILINE
+#define INI_ALLOW_MULTILINE 1
+#endif
+
+/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
+   the file. See http://code.google.com/p/inih/issues/detail?id=21 */
+#ifndef INI_ALLOW_BOM
+#define INI_ALLOW_BOM 1
+#endif
+
+/* Nonzero to allow inline comments (with valid inline comment characters
+   specified by INI_INLINE_COMMENT_PREFIXES). Set to 0 to turn off and match
+   Python 3.2+ configparser behaviour. */
+#ifndef INI_ALLOW_INLINE_COMMENTS
+#define INI_ALLOW_INLINE_COMMENTS 1
+#endif
+#ifndef INI_INLINE_COMMENT_PREFIXES
+#define INI_INLINE_COMMENT_PREFIXES ";"
+#endif
+
+/* Nonzero to use stack, zero to use heap (malloc/free). */
+#ifndef INI_USE_STACK
+#define INI_USE_STACK 1
+#endif
+
+/* Stop parsing on first error (default is to keep parsing). */
+#ifndef INI_STOP_ON_FIRST_ERROR
+#define INI_STOP_ON_FIRST_ERROR 0
+#endif
+
+/* Maximum line length for any line in INI file. */
+#ifndef INI_MAX_LINE
+#define INI_MAX_LINE 200
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+/* inih -- simple .INI file parser
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+https://github.com/benhoyt/inih
+
+*/
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#if !INI_USE_STACK
+#include <stdlib.h>
+#endif
+
+#define MAX_SECTION 50
+#define MAX_NAME 50
+
+/* Strip whitespace chars off end of given string, in place. Return s. */
+inline static char* rstrip(char* s)
+{
+    char* p = s + strlen(s);
+    while (p > s && isspace((unsigned char)(*--p)))
+        *p = '\0';
+    return s;
+}
+
+/* Return pointer to first non-whitespace char in given string. */
+inline static char* lskip(const char* s)
+{
+    while (*s && isspace((unsigned char)(*s)))
+        s++;
+    return (char*)s;
+}
+
+/* Return pointer to first char (of chars) or inline comment in given string,
+   or pointer to null at end of string if neither found. Inline comment must
+   be prefixed by a whitespace character to register as a comment. */
+inline static char* find_chars_or_comment(const char* s, const char* chars)
+{
+#if INI_ALLOW_INLINE_COMMENTS
+    int was_space = 0;
+    while (*s && (!chars || !strchr(chars, *s)) &&
+           !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
+        was_space = isspace((unsigned char)(*s));
+        s++;
+    }
+#else
+    while (*s && (!chars || !strchr(chars, *s))) {
+        s++;
+    }
+#endif
+    return (char*)s;
+}
+
+/* Version of strncpy that ensures dest (size bytes) is null-terminated. */
+inline static char* strncpy0(char* dest, const char* src, size_t size)
+{
+    strncpy(dest, src, size);
+    dest[size - 1] = '\0';
+    return dest;
+}
+
+/* See documentation in header file. */
+inline int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+                     void* user)
+{
+    /* Uses a fair bit of stack (use heap instead if you need to) */
+#if INI_USE_STACK
+    char line[INI_MAX_LINE];
+#else
+    char* line;
+#endif
+    char section[MAX_SECTION] = "";
+    char prev_name[MAX_NAME] = "";
+
+    char* start;
+    char* end;
+    char* name;
+    char* value;
+    int lineno = 0;
+    int error = 0;
+
+#if !INI_USE_STACK
+    line = (char*)malloc(INI_MAX_LINE);
+    if (!line) {
+        return -2;
+    }
+#endif
+
+    /* Scan through stream line by line */
+    while (reader(line, INI_MAX_LINE, stream) != NULL) {
+        lineno++;
+
+        start = line;
+#if INI_ALLOW_BOM
+        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
+                           (unsigned char)start[1] == 0xBB &&
+                           (unsigned char)start[2] == 0xBF) {
+            start += 3;
+        }
+#endif
+        start = lskip(rstrip(start));
+
+        if (*start == ';' || *start == '#') {
+            /* Per Python configparser, allow both ; and # comments at the
+               start of a line */
+        }
+#if INI_ALLOW_MULTILINE
+        else if (*prev_name && *start && start > line) {
+
+#if INI_ALLOW_INLINE_COMMENTS
+        end = find_chars_or_comment(start, NULL);
+        if (*end)
+            *end = '\0';
+        rstrip(start);
+#endif
+
+            /* Non-blank line with leading whitespace, treat as continuation
+               of previous name's value (as per Python configparser). */
+            if (!handler(user, section, prev_name, start) && !error)
+                error = lineno;
+        }
+#endif
+        else if (*start == '[') {
+            /* A "[section]" line */
+            end = find_chars_or_comment(start + 1, "]");
+            if (*end == ']') {
+                *end = '\0';
+                strncpy0(section, start + 1, sizeof(section));
+                *prev_name = '\0';
+            }
+            else if (!error) {
+                /* No ']' found on section line */
+                error = lineno;
+            }
+        }
+        else if (*start) {
+            /* Not a comment, must be a name[=:]value pair */
+            end = find_chars_or_comment(start, "=:");
+            if (*end == '=' || *end == ':') {
+                *end = '\0';
+                name = rstrip(start);
+                value = lskip(end + 1);
+#if INI_ALLOW_INLINE_COMMENTS
+                end = find_chars_or_comment(value, NULL);
+                if (*end)
+                    *end = '\0';
+#endif
+                rstrip(value);
+
+                /* Valid name[=:]value pair found, call handler */
+                strncpy0(prev_name, name, sizeof(prev_name));
+                if (!handler(user, section, name, value) && !error)
+                    error = lineno;
+            }
+            else if (!error) {
+                /* No '=' or ':' found on name[=:]value line */
+                error = lineno;
+            }
+        }
+
+#if INI_STOP_ON_FIRST_ERROR
+        if (error)
+            break;
+#endif
+    }
+
+#if !INI_USE_STACK
+    free(line);
+#endif
+
+    return error;
+}
+
+/* See documentation in header file. */
+inline int ini_parse_file(FILE* file, ini_handler handler, void* user)
+{
+    return ini_parse_stream((ini_reader)fgets, file, handler, user);
+}
+
+/* See documentation in header file. */
+inline int ini_parse(const char* filename, ini_handler handler, void* user)
+{
+    FILE* file;
+    int error;
+
+    file = fopen(filename, "r");
+    if (!file)
+        return -1;
+    error = ini_parse_file(file, handler, user);
+    fclose(file);
+    return error;
+}
+
+#endif /* __INI_H__ */
+
+
+#ifndef __INIREADER_H__
+#define __INIREADER_H__
+
+#include <map>
+#include <set>
+#include <string>
+
+// Read an INI file into easy-to-access name/value pairs. (Note that I've gone
+// for simplicity here rather than speed, but it should be pretty decent.)
+class INIReader
+{
+public:
+    // Empty Constructor
+    INIReader() {};
+  
+    // Construct INIReader and parse given filename. See ini.h for more info
+    // about the parsing.
+    INIReader(std::string filename);
+
+    // Return the result of ini_parse(), i.e., 0 on success, line number of
+    // first error on parse error, or -1 on file open error.
+    int ParseError() const;
+
+    // Return the list of sections found in ini file
+    std::set<std::string> Sections();
+
+    // Get a string value from INI file, returning default_value if not found.
+    std::string Get(std::string section, std::string name,
+                    std::string default_value);
+
+    // Get an integer (long) value from INI file, returning default_value if
+    // not found or not a valid integer (decimal "1234", "-1234", or hex "0x4d2").
+    long GetInteger(std::string section, std::string name, long default_value);
+
+    // Get a real (floating point double) value from INI file, returning
+    // default_value if not found or not a valid floating point value
+    // according to strtod().
+    double GetReal(std::string section, std::string name, double default_value);
+
+    // Get a boolean value from INI file, returning default_value if not found or if
+    // not a valid true/false value. Valid true values are "true", "yes", "on", "1",
+    // and valid false values are "false", "no", "off", "0" (not case sensitive).
+    bool GetBoolean(std::string section, std::string name, bool default_value);
+
+private:
+    int _error;
+    std::map<std::string, std::string> _values;
+    std::set<std::string> _sections;
+    static std::string MakeKey(std::string section, std::string name);
+    static int ValueHandler(void* user, const char* section, const char* name,
+                            const char* value);
+};
+
+#endif  // __INIREADER_H__
+
+
+#ifndef __INIREADER__
+#define __INIREADER__
+
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+
+using std::string;
+
+inline INIReader::INIReader(string filename)
+{
+    _error = ini_parse(filename.c_str(), ValueHandler, this);
+}
+
+inline int INIReader::ParseError() const
+{
+    return _error;
+}
+
+inline std::set<string> INIReader::Sections()
+{
+    return _sections;
+}
+
+inline string INIReader::Get(string section, string name, string default_value)
+{
+    string key = MakeKey(section, name);
+    return _values.count(key) ? _values[key] : default_value;
+}
+
+inline long INIReader::GetInteger(string section, string name, long default_value)
+{
+    string valstr = Get(section, name, "");
+    const char* value = valstr.c_str();
+    char* end;
+    // This parses "1234" (decimal) and also "0x4D2" (hex)
+    long n = strtol(value, &end, 0);
+    return end > value ? n : default_value;
+}
+
+inline double INIReader::GetReal(string section, string name, double default_value)
+{
+    string valstr = Get(section, name, "");
+    const char* value = valstr.c_str();
+    char* end;
+    double n = strtod(value, &end);
+    return end > value ? n : default_value;
+}
+
+inline bool INIReader::GetBoolean(string section, string name, bool default_value)
+{
+    string valstr = Get(section, name, "");
+    // Convert to lower case to make string comparisons case-insensitive
+    std::transform(valstr.begin(), valstr.end(), valstr.begin(), ::tolower);
+    if (valstr == "true" || valstr == "yes" || valstr == "on" || valstr == "1")
+        return true;
+    else if (valstr == "false" || valstr == "no" || valstr == "off" || valstr == "0")
+        return false;
+    else
+        return default_value;
+}
+
+inline string INIReader::MakeKey(string section, string name)
+{
+    string key = section + "=" + name;
+    // Convert to lower case to make section/name lookups case-insensitive
+    std::transform(key.begin(), key.end(), key.begin(), ::tolower);
+    return key;
+}
+
+inline int INIReader::ValueHandler(void* user, const char* section, const char* name,
+                            const char* value)
+{
+    INIReader* reader = (INIReader*)user;
+    string key = MakeKey(section, name);
+    if (reader->_values[key].size() > 0)
+        reader->_values[key] += "\n";
+    reader->_values[key] += value;
+    reader->_sections.insert(section);
+    return 1;
+}
+
+#endif  // __INIREADER__
diff --git a/include/boost/sml.hpp b/include/boost/sml.hpp
new file mode 100644
index 0000000..a28bddf
--- /dev/null
+++ b/include/boost/sml.hpp
@@ -0,0 +1,2535 @@
+//
+// Copyright (c) 2016-2018 Kris Jusiak (kris at jusiak dot net)
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#ifndef BOOST_SML_HPP
+#define BOOST_SML_HPP
+#if (__cplusplus < 201305L && _MSC_VER < 1900)
+#error "[Boost].SML requires C++14 support (Clang-3.4+, GCC-5.1+, MSVC-2015+)"
+#else
+#define BOOST_SML_VERSION 1'1'0
+#define BOOST_SML_NAMESPACE_BEGIN \
+  namespace boost {               \
+  namespace sml {                 \
+  inline namespace v1_1_0 {
+#define BOOST_SML_NAMESPACE_END \
+  }                             \
+  }                             \
+  }
+#if defined(__clang__)
+#define __BOOST_SML_UNUSED __attribute__((unused))
+#define __BOOST_SML_VT_INIT \
+  {}
+#define __BOOST_SML_ZERO_SIZE_ARRAY(...) __VA_ARGS__ _[0]
+#define __BOOST_SML_ZERO_SIZE_ARRAY_CREATE(...)
+#define __BOOST_SML_TEMPLATE_KEYWORD template
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wgnu-string-literal-operator-template"
+#pragma clang diagnostic ignored "-Wzero-length-array"
+#elif defined(__GNUC__)
+#if !defined(__has_builtin)
+#define __has_builtin(...) 0
+#endif
+#define __BOOST_SML_UNUSED __attribute__((unused))
+#define __BOOST_SML_VT_INIT \
+  {}
+#define __BOOST_SML_ZERO_SIZE_ARRAY(...) __VA_ARGS__ _[0]
+#define __BOOST_SML_ZERO_SIZE_ARRAY_CREATE(...) __VA_ARGS__ ? __VA_ARGS__ : 1
+#define __BOOST_SML_TEMPLATE_KEYWORD template
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wpedantic"
+#elif defined(_MSC_VER)
+#define __has_builtin(...) __has_builtin##__VA_ARGS__
+#define __has_builtin__make_integer_seq(...) 1
+#define __BOOST_SML_UNUSED
+#define __BOOST_SML_VT_INIT
+#define __BOOST_SML_ZERO_SIZE_ARRAY(...)
+#define __BOOST_SML_ZERO_SIZE_ARRAY_CREATE(...) __VA_ARGS__ ? __VA_ARGS__ : 1
+#if (_MSC_VER >= 1910)  // MSVC 2017
+#define __BOOST_SML_TEMPLATE_KEYWORD template
+#else
+#define __BOOST_SML_TEMPLATE_KEYWORD
+#endif
+#pragma warning(disable : 4503)
+#pragma warning(disable : 4200)
+#endif
+BOOST_SML_NAMESPACE_BEGIN
+#define __BOOST_SML_REQUIRES(...) typename aux::enable_if<__VA_ARGS__, int>::type = 0
+namespace aux {
+using byte = unsigned char;
+struct none_type {};
+template <class...>
+struct type {};
+template <class T, T>
+struct non_type {};
+template <class, class>
+struct pair {};
+template <class...>
+struct type_list {
+  using type = type_list;
+};
+template <bool...>
+struct bool_list {
+  using type = bool_list;
+};
+template <class... Ts>
+struct inherit : Ts... {
+  using type = inherit;
+};
+template <class T>
+struct identity {
+  using type = T;
+};
+template <class T>
+T &&declval();
+template <class T, T V>
+struct integral_constant {
+  using type = integral_constant;
+  static constexpr T value = V;
+};
+using true_type = integral_constant<bool, true>;
+using false_type = integral_constant<bool, false>;
+template <class... Ts>
+using void_t = void;
+template <class...>
+struct always : true_type {};
+template <class...>
+struct never : false_type {};
+template <bool B, class T, class F>
+struct conditional {
+  using type = T;
+};
+template <class T, class F>
+struct conditional<false, T, F> {
+  using type = F;
+};
+template <bool B, class T, class F>
+using conditional_t = typename conditional<B, T, F>::type;
+template <bool B, class T = void>
+struct enable_if {};
+template <class T>
+struct enable_if<true, T> {
+  using type = T;
+};
+template <bool B, class T = void>
+using enable_if_t = typename enable_if<B, T>::type;
+template <class, class>
+struct is_same : false_type {};
+template <class T>
+struct is_same<T, T> : true_type {};
+template <class T, class U>
+#if defined(_MSC_VER)
+struct is_base_of : integral_constant<bool, __is_base_of(T, U)> {
+};
+#else
+using is_base_of = integral_constant<bool, __is_base_of(T, U)>;
+#endif
+template <class T, class... TArgs>
+decltype(T(declval<TArgs>()...), true_type{}) test_is_constructible(int);
+template <class, class...>
+false_type test_is_constructible(...);
+template <class T, class... TArgs>
+#if defined(_MSC_VER)
+struct is_constructible : decltype(test_is_constructible<T, TArgs...>(0)) {
+};
+#else
+using is_constructible = decltype(test_is_constructible<T, TArgs...>(0));
+#endif
+template <class T, class U>
+struct is_empty_base : T {
+  U _;
+};
+template <class T>
+struct is_empty : aux::integral_constant<bool, sizeof(is_empty_base<T, none_type>) == sizeof(none_type)> {};
+template <class>
+struct function_traits;
+template <class R, class... TArgs>
+struct function_traits<R (*)(TArgs...)> {
+  using args = type_list<TArgs...>;
+};
+template <class R, class... TArgs>
+struct function_traits<R(TArgs...)> {
+  using args = type_list<TArgs...>;
+};
+template <class R, class T, class... TArgs>
+struct function_traits<R (T::*)(TArgs...)> {
+  using args = type_list<TArgs...>;
+};
+template <class R, class T, class... TArgs>
+struct function_traits<R (T::*)(TArgs...) const> {
+  using args = type_list<TArgs...>;
+};
+#if __cplusplus > 201402L && __cpp_noexcept_function_type >= 201510
+template <class R, class... TArgs>
+struct function_traits<R (*)(TArgs...) noexcept> {
+  using args = type_list<TArgs...>;
+};
+template <class R, class... TArgs>
+struct function_traits<R(TArgs...) noexcept> {
+  using args = type_list<TArgs...>;
+};
+template <class R, class T, class... TArgs>
+struct function_traits<R (T::*)(TArgs...) noexcept> {
+  using args = type_list<TArgs...>;
+};
+template <class R, class T, class... TArgs>
+struct function_traits<R (T::*)(TArgs...) const noexcept> {
+  using args = type_list<TArgs...>;
+};
+#endif
+template <class T>
+using function_traits_t = typename function_traits<T>::args;
+template <class T>
+struct remove_const {
+  using type = T;
+};
+template <class T>
+struct remove_const<const T> {
+  using type = T;
+};
+template <class T>
+using remove_const_t = typename remove_const<T>::type;
+template <class T>
+struct remove_reference {
+  using type = T;
+};
+template <class T>
+struct remove_reference<T &> {
+  using type = T;
+};
+template <class T>
+struct remove_reference<T &&> {
+  using type = T;
+};
+template <class T>
+using remove_reference_t = typename remove_reference<T>::type;
+}
+namespace aux {
+using swallow = int[];
+template <int...>
+struct index_sequence {
+  using type = index_sequence;
+};
+#if __has_builtin(__make_integer_seq)
+template <class T, T...>
+struct integer_sequence;
+template <int... Ns>
+struct integer_sequence<int, Ns...> {
+  using type = index_sequence<Ns...>;
+};
+template <int N>
+struct make_index_sequence_impl {
+  using type = typename __make_integer_seq<integer_sequence, int, N>::type;
+};
+#else
+template <class, class>
+struct concat;
+template <int... I1, int... I2>
+struct concat<index_sequence<I1...>, index_sequence<I2...>> : index_sequence<I1..., (sizeof...(I1) + I2)...> {};
+template <int N>
+struct make_index_sequence_impl
+    : concat<typename make_index_sequence_impl<N / 2>::type, typename make_index_sequence_impl<N - N / 2>::type>::type {};
+template <>
+struct make_index_sequence_impl<0> : index_sequence<> {};
+template <>
+struct make_index_sequence_impl<1> : index_sequence<0> {};
+#endif
+template <int N>
+using make_index_sequence = typename make_index_sequence_impl<N>::type;
+template <class...>
+struct join {
+  using type = type_list<>;
+};
+template <class T>
+struct join<T> {
+  using type = T;
+};
+template <class... Ts>
+struct join<type_list<Ts...>> : type_list<Ts...> {};
+template <class... T1s, class... T2s>
+struct join<type_list<T1s...>, type_list<T2s...>> : type_list<T1s..., T2s...> {};
+template <class... T1s, class... T2s, class... T3s>
+struct join<type_list<T1s...>, type_list<T2s...>, type_list<T3s...>> : type_list<T1s..., T2s..., T3s...> {};
+template <class... T1s, class... T2s, class... Ts>
+struct join<type_list<T1s...>, type_list<T2s...>, Ts...> : join<type_list<T1s..., T2s...>, Ts...> {};
+template <class... Ts, class... T1s, class... T2s, class... T3s, class... T4s, class... T5s, class... T6s, class... T7s,
+          class... T8s, class... T9s, class... T10s, class... T11s, class... T12s, class... T13s, class... T14s, class... T15s,
+          class... T16s, class... Us>
+struct join<type_list<Ts...>, type_list<T1s...>, type_list<T2s...>, type_list<T3s...>, type_list<T4s...>, type_list<T5s...>,
+            type_list<T6s...>, type_list<T7s...>, type_list<T8s...>, type_list<T9s...>, type_list<T10s...>, type_list<T11s...>,
+            type_list<T12s...>, type_list<T13s...>, type_list<T14s...>, type_list<T15s...>, type_list<T16s...>, Us...>
+    : join<type_list<Ts..., T1s..., T2s..., T3s..., T4s..., T5s..., T6s..., T7s..., T8s..., T9s..., T10s..., T11s..., T12s...,
+                     T13s..., T14s..., T15s..., T16s...>,
+           Us...> {};
+template <class... TArgs>
+using join_t = typename join<TArgs...>::type;
+template <class, class...>
+struct unique_impl;
+template <class T1, class T2, class... Rs, class... Ts>
+struct unique_impl<type<T1, Rs...>, T2, Ts...>
+    : conditional_t<is_base_of<type<T2>, T1>::value, unique_impl<type<inherit<T1>, Rs...>, Ts...>,
+                    unique_impl<type<inherit<T1, type<T2>>, Rs..., T2>, Ts...>> {};
+template <class T1, class... Rs>
+struct unique_impl<type<T1, Rs...>> : type_list<Rs...> {};
+template <class... Ts>
+struct unique : unique_impl<type<none_type>, Ts...> {};
+template <class T>
+struct unique<T> : type_list<T> {};
+template <class... Ts>
+using unique_t = typename unique<Ts...>::type;
+template <class, class...>
+struct is_unique;
+template <class T>
+struct is_unique<T> : true_type {};
+template <class T1, class T2, class... Ts>
+struct is_unique<T1, T2, Ts...>
+    : conditional_t<is_base_of<type<T2>, T1>::value, false_type, is_unique<inherit<T1, type<T2>>, Ts...>> {};
+template <class... Ts>
+using is_unique_t = is_unique<none_type, Ts...>;
+template <template <class...> class, class>
+struct apply;
+template <template <class...> class T, template <class...> class U, class... Ts>
+struct apply<T, U<Ts...>> {
+  using type = T<Ts...>;
+};
+template <template <class...> class T, class D>
+using apply_t = typename apply<T, D>::type;
+template <int, class T>
+struct tuple_type {
+  explicit tuple_type(const T &object) : value(object) {}
+  T value;
+};
+template <class, class...>
+struct tuple_impl;
+template <int... Ns, class... Ts>
+struct tuple_impl<index_sequence<Ns...>, Ts...> : tuple_type<Ns, Ts>... {
+  explicit tuple_impl(Ts... ts) : tuple_type<Ns, Ts>(ts)... {}
+};
+template <>
+struct tuple_impl<index_sequence<0>> {
+  __BOOST_SML_ZERO_SIZE_ARRAY(byte);
+};
+template <class... Ts>
+using tuple = tuple_impl<make_index_sequence<sizeof...(Ts)>, Ts...>;
+template <int N, class T>
+T &get_by_id(tuple_type<N, T> *object) {
+  return static_cast<tuple_type<N, T> &>(*object).value;
+}
+struct init {};
+struct pool_type_base {
+  __BOOST_SML_ZERO_SIZE_ARRAY(byte);
+};
+template <class T>
+struct pool_type : pool_type_base {
+  explicit pool_type(T object) : value{object} {}
+  template <class TObject>
+  pool_type(init i, TObject object) : value{i, object} {}
+  T value;
+};
+template <class T>
+struct missing_ctor_parameter {
+  static constexpr auto value = false;
+  auto operator()() const { return T{}(); }
+  template <class U, __BOOST_SML_REQUIRES(!aux::is_base_of<pool_type_base, U>::value && aux::is_constructible<U>::value)>
+  operator U() {
+    return {};
+  }
+#if !defined(_MSC_VER)
+  template <class TMissing, __BOOST_SML_REQUIRES(!aux::is_base_of<pool_type_base, TMissing>::value)>
+  operator TMissing &() const {
+    static_assert(missing_ctor_parameter<TMissing>::value,
+                  "State Machine is missing a constructor parameter! Check out the `missing_ctor_parameter` error to see the "
+                  "missing type.");
+  }
+#endif
+};
+template <class T>
+missing_ctor_parameter<T> try_get(...) {
+  return {};
+}
+template <class T>
+T try_get(const pool_type<T> *object) {
+  return object->value;
+}
+template <class T>
+const T &try_get(const pool_type<const T &> *object) {
+  return object->value;
+}
+template <class T>
+T &try_get(const pool_type<T &> *object) {
+  return object->value;
+}
+template <class T, class TPool>
+T &get(TPool &p) {
+  return static_cast<pool_type<T> &>(p).value;
+}
+template <class T, class TPool>
+const T &cget(const TPool &p) {
+  return static_cast<const pool_type<T> &>(p).value;
+}
+template <class... Ts>
+struct pool : pool_type<Ts>... {
+  using boost_di_inject__ = type_list<Ts...>;
+  pool() = default;
+  explicit pool(Ts... ts) : pool_type<Ts>(ts)... {}
+  template <class... TArgs>
+  pool(init, const pool<TArgs...> &p) : pool_type<Ts>(try_get<aux::remove_const_t<aux::remove_reference_t<Ts>>>(&p))... {}
+  template <class... TArgs>
+  pool(const pool<TArgs...> &p) : pool_type<Ts>(init{}, p)... {}
+};
+template <>
+struct pool<> {
+  using boost_di_inject__ = type_list<>;
+  pool() = default;
+  template <class... Ts>
+  explicit pool(Ts &&...) {}
+  __BOOST_SML_ZERO_SIZE_ARRAY(byte);
+};
+template <int, class>
+struct type_id_type {};
+template <class, class...>
+struct type_id_impl;
+template <int... Ns, class... Ts>
+struct type_id_impl<index_sequence<Ns...>, Ts...> : type_id_type<Ns, Ts>... {};
+template <class... Ts>
+struct type_id : type_id_impl<make_index_sequence<sizeof...(Ts)>, Ts...> {};
+template <class R, class T, int N>
+constexpr R get_id(type_id_type<N, T> *) {
+  return static_cast<R>(N);
+}
+template <template <class...> class, class T>
+struct is : false_type {};
+template <template <class...> class T, class... Ts>
+struct is<T, T<Ts...>> : true_type {};
+template <class>
+struct size;
+template <template <class...> class T, class... Ts>
+struct size<T<Ts...>> {
+  static constexpr auto value = sizeof...(Ts);
+};
+#if defined(_MSC_VER)
+constexpr int max_impl() { return 0; }
+constexpr int max_impl(int r) { return r; }
+constexpr int max_impl(int r, int i) { return r > i ? r : i; }
+constexpr int max_impl(int r, int i, int ints...) { return i > r ? max_impl(i, ints) : max_impl(r, ints); }
+template <int... Ts>
+constexpr int max() {
+  return max_impl(Ts...);
+}
+#else
+template <int... Ts>
+constexpr int max() {
+  int max = 0;
+  (void)swallow{0, (Ts > max ? max = Ts : max)...};
+  return max;
+}
+#endif
+template <class TExpr, class = void>
+struct zero_wrapper : TExpr {
+  explicit zero_wrapper(const TExpr &expr) : TExpr(expr) {}
+  const TExpr &get() const { return *this; }
+};
+template <class, class>
+struct zero_wrapper_impl;
+template <class TExpr, class... TArgs>
+struct zero_wrapper_impl<TExpr, type_list<TArgs...>> {
+  auto operator()(TArgs... args) const { return reinterpret_cast<const TExpr &>(*this)(args...); }
+  __BOOST_SML_ZERO_SIZE_ARRAY(byte);
+};
+template <class TExpr>
+struct zero_wrapper<TExpr, void_t<decltype(+declval<TExpr>())>>
+    : zero_wrapper_impl<TExpr, function_traits_t<decltype(&TExpr::operator())>> {
+  template <class... Ts>
+  zero_wrapper(Ts &&...) {}
+  const TExpr &get() const { return reinterpret_cast<const TExpr &>(*this); }
+};
+namespace detail {
+template <class, int N, int... Ns>
+auto get_type_name(const char *ptr, index_sequence<Ns...>) {
+  static const char str[] = {ptr[N + Ns]..., 0};
+  return str;
+}
+}
+template <class T>
+const char *get_type_name() {
+#if defined(_MSC_VER)
+  return detail::get_type_name<T, 34>(__FUNCSIG__, make_index_sequence<sizeof(__FUNCSIG__) - 34 - 8>{});
+#elif defined(__clang__)
+  return detail::get_type_name<T, 58>(__PRETTY_FUNCTION__, make_index_sequence<sizeof(__PRETTY_FUNCTION__) - 58 - 2>{});
+#elif defined(__GNUC__)
+  return detail::get_type_name<T, 63>(__PRETTY_FUNCTION__, make_index_sequence<sizeof(__PRETTY_FUNCTION__) - 63 - 2>{});
+#endif
+}
+template <class T, T...>
+struct string;
+template <char... Chrs>
+struct string<char, Chrs...> {
+  using type = string;
+  static auto c_str() {
+    static constexpr char str[] = {Chrs..., 0};
+    return str;
+  }
+};
+template <class T>
+struct string<T> {
+  using type = T;
+  static auto c_str() { return c_str_impl((T *)0); }
+  template <class U>
+  static decltype(U::c_str()) c_str_impl(U *) {
+    return U::c_str();
+  }
+  static auto c_str_impl(...) { return get_type_name<T>(); }
+};
+}
+namespace back {
+namespace policies {
+struct defer_queue_policy__ {};
+template <template <class...> class T>
+struct defer_queue : aux::pair<back::policies::defer_queue_policy__, defer_queue<T>> {
+  template <class U>
+  using rebind = T<U>;
+};
+}
+}
+namespace back {
+template <class... Ts>
+class queue_event {
+  using ids_t = aux::type_id<Ts...>;
+  static constexpr auto alignment = aux::max<alignof(Ts)...>();
+  static constexpr auto size = aux::max<sizeof(Ts)...>();
+  template <class T>
+  static void dtor_impl(aux::byte *data) {
+    (void)data;
+    reinterpret_cast<T *>(data)->~T();
+  }
+  template <class T>
+  static void move_impl(aux::byte (&data)[size], queue_event &&other) {
+    new (&data) T(static_cast<T &&>(*reinterpret_cast<T *>(other.data)));
+  }
+
+ public:
+  queue_event(queue_event &&other) : id(other.id), dtor(other.dtor), move(other.move) {
+    move(data, static_cast<queue_event &&>(other));
+  }
+  queue_event(const queue_event &) = delete;
+  queue_event &operator=(const queue_event &) = delete;
+  template <class T>
+  queue_event(T object) {
+    id = aux::get_id<int, T>((ids_t *)0);
+    dtor = &dtor_impl<T>;
+    move = &move_impl<T>;
+    new (&data) T(static_cast<T &&>(object));
+  }
+  ~queue_event() { dtor(data); }
+  alignas(alignment) aux::byte data[size];
+  int id = -1;
+
+ private:
+  void (*dtor)(aux::byte *);
+  void (*move)(aux::byte (&)[size], queue_event &&);
+};
+template <class TEvent>
+class queue_event_call {
+  using call_t = void (*)(void *, const TEvent &);
+
+ public:
+  queue_event_call() = default;
+  explicit queue_event_call(const call_t &call) : call{call} {}
+  call_t call{};
+};
+template <class... TEvents>
+struct queue_handler : queue_event_call<TEvents>... {
+  queue_handler() = default;
+  template <class TQueue, class = typename TQueue::container_type>
+  explicit queue_handler(TQueue &queue)
+      : queue_event_call<TEvents>(queue_handler::push_impl<TQueue, TEvents>)..., queue_{&queue} {}
+  template <class TEvent>
+  void operator()(const TEvent &event) {
+    static_cast<queue_event_call<TEvent> *>(this)->call(queue_, event);
+  }
+
+ private:
+  template <class TQueue, class TEvent>
+  static auto push_impl(void *queue, const TEvent &event) {
+    static_cast<TQueue *>(queue)->push(event);
+  }
+  void *queue_{};
+};
+}
+namespace back {
+struct _ {};
+struct initial {};
+struct unexpected {};
+struct entry_exit {};
+struct terminate_state {
+  static auto c_str() { return "terminate"; }
+};
+struct internal_event {
+  static auto c_str() { return "internal_event"; }
+};
+struct anonymous : internal_event {
+  static auto c_str() { return "anonymous"; }
+};
+template <class T, class TEvent = T>
+struct on_entry : internal_event, entry_exit {
+  static auto c_str() { return "on_entry"; }
+  explicit on_entry(const TEvent &event = {}) : event_(event) {}
+  const TEvent &event_;
+};
+template <class T, class TEvent = T>
+struct on_exit : internal_event, entry_exit {
+  static auto c_str() { return "on_exit"; }
+  explicit on_exit(const TEvent &event = {}) : event_(event) {}
+  const TEvent &event_;
+};
+template <class T, class TException = T>
+struct exception : internal_event {
+  using type = TException;
+  explicit exception(const TException &exception = {}) : exception_(exception) {}
+  const TException &exception_;
+};
+template <class T, class TEvent = T>
+struct unexpected_event : internal_event, unexpected {
+  explicit unexpected_event(const TEvent &event = {}) : event_(event) {}
+  const TEvent &event_;
+};
+template <class TEvent>
+struct event_type {
+  using event_t = TEvent;
+  using generic_t = TEvent;
+  using mapped_t = void;
+};
+template <class TEvent>
+struct event_type<exception<TEvent>> {
+  using event_t = TEvent;
+  using generic_t = exception<TEvent>;
+  using mapped_t = void;
+};
+template <class TEvent, class T>
+struct event_type<unexpected_event<T, TEvent>> {
+  using event_t = TEvent;
+  using generic_t = unexpected_event<T>;
+  using mapped_t = void;
+};
+template <class TEvent, class T>
+struct event_type<on_entry<T, TEvent>> {
+  using event_t = TEvent;
+  using generic_t = on_entry<T>;
+  using mapped_t = on_entry<T, TEvent>;
+};
+template <class TEvent, class T>
+struct event_type<on_exit<T, TEvent>> {
+  using event_t = TEvent;
+  using generic_t = on_exit<T>;
+  using mapped_t = on_exit<T, TEvent>;
+};
+template <class TEvent>
+using get_event_t = typename event_type<TEvent>::event_t;
+template <class TEvent>
+using get_generic_t = typename event_type<TEvent>::generic_t;
+template <class TEvent>
+using get_mapped_t = typename event_type<TEvent>::mapped_t;
+template <class... TEvents>
+struct process : queue_handler<TEvents...> {
+  using queue_handler<TEvents...>::queue_handler;
+};
+template <class... TEvents>
+struct defer : queue_handler<TEvents...> {
+  using queue_handler<TEvents...>::queue_handler;
+};
+}
+namespace back {
+template <class>
+class sm;
+template <class>
+struct sm_impl;
+template <class, class...>
+struct sm_policy;
+template <class TEvent>
+using get_event = aux::conditional_t<aux::is_base_of<internal_event, TEvent>::value, aux::type_list<>, aux::type_list<TEvent>>;
+template <class, class, class TEvent>
+struct get_all_events_impl {
+  using type = get_event<TEvent>;
+};
+template <class TSrc, class TDst, class TEvent>
+struct get_all_events_impl<TSrc, TDst, unexpected_event<TEvent>> {
+  using type = aux::type_list<TEvent>;
+};
+template <class TSrc, class TDst, class TEvent>
+struct get_all_events_impl<sm<TSrc>, TDst, TEvent> {
+  using type = aux::join_t<get_event<TEvent>, typename sm<TSrc>::events>;
+};
+template <class TSrc, class TDst, class TEvent>
+struct get_all_events_impl<TSrc, sm<TDst>, TEvent> {
+  using type = aux::join_t<get_event<TEvent>, typename sm<TDst>::events>;
+};
+template <class TSrc, class TDst, class TEvent>
+struct get_all_events_impl<sm<TSrc>, sm<TDst>, TEvent> {
+  using type = aux::join_t<get_event<TEvent>, typename sm<TSrc>::events, typename sm<TDst>::events>;
+};
+template <class, class TEvent>
+struct get_sub_internal_events_impl {
+  using type = aux::conditional_t<aux::is_base_of<internal_event, TEvent>::value, aux::type_list<TEvent>, aux::type_list<>>;
+};
+template <class T, class TEvent>
+struct get_sub_internal_events_impl<sm<T>, TEvent> {
+  using type = aux::join_t<aux::type_list<TEvent>, typename sm_impl<T>::sub_internal_events_t>;
+};
+template <class... Ts>
+using get_all_events =
+    aux::join_t<typename get_all_events_impl<typename Ts::src_state, typename Ts::dst_state, typename Ts::event>::type...>;
+template <class... Ts>
+using get_sub_internal_events =
+    aux::join_t<typename get_sub_internal_events_impl<typename Ts::src_state, typename Ts::event>::type...>;
+template <class... Ts>
+using get_events = aux::type_list<typename Ts::event...>;
+template <class T>
+struct get_exception : aux::type_list<> {};
+template <class T>
+struct get_exception<exception<T>> : aux::type_list<exception<T>> {};
+template <class... Ts>
+using get_exceptions = aux::join_t<typename get_exception<Ts>::type...>;
+template <class... Ts>
+using get_states = aux::join_t<aux::type_list<typename Ts::src_state, typename Ts::dst_state>...>;
+template <class... Ts>
+using get_initial_states =
+    aux::join_t<typename aux::conditional<Ts::initial, aux::type_list<typename Ts::src_state>, aux::type_list<>>::type...>;
+template <class... Ts>
+using get_history_states = aux::join_t<
+    typename aux::conditional<!Ts::history && Ts::initial, aux::type_list<typename Ts::src_state>, aux::type_list<>>::type...>;
+template <class>
+struct get_sub_sm : aux::type_list<> {};
+template <class T>
+struct get_sub_sm<sm<T>> : aux::join_t<aux::type_list<T>, typename sm<T>::state_machines> {};
+template <class... Ts>
+using get_sub_sms = aux::join_t<typename get_sub_sm<Ts>::type...>;
+template <class... Ts>
+using get_sm_t = aux::type_list<typename Ts::sm...>;
+template <class... Ts>
+using get_non_empty_t =
+    aux::join_t<typename aux::conditional<aux::is_empty<Ts>::value, aux::type_list<>, aux::type_list<Ts>>::type...>;
+template <class... Ts>
+using merge_deps = aux::join_t<typename Ts::deps...>;
+template <class>
+struct sub_sm;
+template <class T>
+struct sub_sm<sm_impl<sm_policy<T>>> {
+  template <class U, class... TPolicies>
+  static sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>> &get(
+      aux::pool_type<sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>>> *object) {
+    return static_cast<aux::pool_type<sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>>> &>(*object).value;
+  }
+  template <class... TPolicies>
+  static sm_impl<sm_policy<T, TPolicies...>> &get(aux::pool_type<sm_impl<sm_policy<T, TPolicies...>>> *object) {
+    return static_cast<aux::pool_type<sm_impl<sm_policy<T, TPolicies...>>> &>(*object).value;
+  }
+  template <class... TPolicies>
+  static const sm_impl<sm_policy<T, TPolicies...>> &cget(const aux::pool_type<sm_impl<sm_policy<T, TPolicies...>>> *object) {
+    return static_cast<const aux::pool_type<sm_impl<sm_policy<T, TPolicies...>>> &>(*object).value;
+  }
+};
+template <class T, class U>
+struct sub_sm<sm_impl<sm_policy<T, aux::identity<U>>>> {
+  template <class... TPolicies>
+  static sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>> &get(
+      aux::pool_type<sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>>> *object) {
+    return static_cast<aux::pool_type<sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>>> &>(*object).value;
+  }
+  template <class... TPolicies>
+  static const sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>> &cget(
+      const aux::pool_type<sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>>> *object) {
+    return static_cast<const aux::pool_type<sm_impl<sm_policy<T, aux::identity<U>, TPolicies...>>> &>(*object).value;
+  }
+};
+template <class T, class... TPolicies>
+struct rebind_impl {
+  using type = sm_policy<T, TPolicies...>;
+};
+template <class T, class... TDetails, class... TPolicies>
+struct rebind_impl<sm_policy<T, TDetails...>, TPolicies...> {
+  using type = sm_policy<T, TDetails..., TPolicies...>;
+};
+template <class T, class... TDetails, class... TPolicies>
+struct rebind_impl<sm<sm_policy<T, TDetails...>>, TPolicies...> {
+  using type = sm_policy<T, TDetails..., TPolicies...>;
+};
+template <class, class>
+struct convert_to_sm;
+template <class T, class... Ts>
+struct convert_to_sm<T, aux::type_list<Ts...>> {
+  using type = aux::type_list<sm_impl<T>, sm_impl<typename T::template rebind<Ts>>...>;
+};
+}
+namespace back {
+template <class>
+class sm;
+template <class>
+struct sm_impl;
+template <class...>
+struct transitions;
+template <class...>
+struct transitions_sub;
+template <class T, class... Ts>
+struct transitions<T, Ts...> {
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
+    if (aux::get<T>(sm.transitions_).execute(event, sm, deps, subs, current_state, typename SM::has_entry_exits{})) {
+      return true;
+    }
+    return transitions<Ts...>::execute(event, sm, deps, subs, current_state);
+  }
+};
+template <class T>
+struct transitions<T> {
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
+    return execute_impl(event, sm, deps, subs, current_state);
+  }
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute_impl(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
+    return aux::get<T>(sm.transitions_).execute(event, sm, deps, subs, current_state, typename SM::has_entry_exits{});
+  }
+  template <class _, class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute_impl(const on_exit<_, TEvent> &event, SM &sm, TDeps &deps, TSubs &subs,
+                           typename SM::state_t &current_state) {
+    aux::get<T>(sm.transitions_).execute(event, sm, deps, subs, current_state, typename SM::has_entry_exits{});
+    return false;
+  }
+};
+template <>
+struct transitions<aux::true_type> {
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
+    sm.process_internal_event(unexpected_event<TEvent>{event}, deps, subs, current_state);
+    return false;
+  }
+};
+template <>
+struct transitions<aux::false_type> {
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute(const TEvent &, SM &, TDeps &, TSubs &, typename SM::state_t &) {
+    return false;
+  }
+};
+template <class TSM, class T, class... Ts>
+struct transitions_sub<sm<TSM>, T, Ts...> {
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
+    return execute_impl(event, sm, deps, subs, current_state);
+  }
+  template <class, class SM, class TDeps, class TSubs>
+  static bool execute(const anonymous &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
+    if (sub_sm<sm_impl<TSM>>::cget(&subs).is_terminated()) {
+      const auto handled = sub_sm<sm_impl<TSM>>::get(&subs).process_event(event, deps, subs);
+      return handled ? handled : transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
+    }
+    return false;
+  }
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute_impl(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state) {
+    const auto handled = sub_sm<sm_impl<TSM>>::get(&subs).process_event(event, deps, subs);
+    return handled ? handled : transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
+  }
+  template <class _, class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute_impl(const back::on_entry<_, TEvent> &event, SM &sm, TDeps &deps, TSubs &subs,
+                           typename SM::state_t &current_state) {
+    transitions<T, Ts...>::execute(event, sm, deps, subs, current_state);
+    sub_sm<sm_impl<TSM>>::get(&subs).process_event(event, deps, subs);
+    return true;
+  }
+};
+template <class TSM>
+struct transitions_sub<sm<TSM>> {
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  static bool execute(const TEvent &event, SM &, TDeps &deps, TSubs &subs, typename SM::state_t &) {
+    sub_sm<sm_impl<TSM>>::get(&subs).template process_event<TEvent>(event, deps, subs);
+    return true;
+  }
+};
+}
+namespace back {
+template <class>
+class sm;
+template <class>
+struct state;
+template <class>
+struct event;
+template <class...>
+struct transitions;
+template <class...>
+struct transitions_sub;
+template <class, class>
+struct state_mappings;
+template <class S, class... Ts>
+struct state_mappings<S, aux::type_list<Ts...>> {
+  using element_type = state<S>;
+  using types = aux::type_list<Ts...>;
+};
+template <class, class>
+struct event_mappings;
+template <class E, class... Ts>
+struct event_mappings<E, aux::inherit<Ts...>> {
+  using element_type = event<E>;
+  using types = aux::type_list<Ts...>;
+};
+template <class...>
+struct unique_mappings;
+template <class, class...>
+struct unique_mappings_impl;
+template <class... Ts>
+using unique_mappings_t = typename unique_mappings<Ts...>::type;
+template <class, class, class, class R>
+struct get_mapping : aux::type_list<R> {};
+template <class E, class T, class R>
+struct get_mapping<event<E>, event<E>, T, R>
+    : aux::type_list<event_mappings<E, aux::apply_t<unique_mappings_t, aux::join_t<typename R::types, typename T::types>>>> {};
+template <class S, class T, class R>
+struct get_mapping<state<S>, state<S>, T, R>
+    : aux::type_list<state_mappings<S, aux::join_t<typename R::types, typename T::types>>> {};
+template <class T, class... Ts>
+struct extend_mapping : aux::join_t<typename get_mapping<typename T::element_type, typename Ts::element_type, T, Ts>::type...> {
+};
+template <class T, class... Ts>
+using extend_mapping_t = aux::apply_t<aux::inherit, typename extend_mapping<T, Ts...>::type>;
+template <bool, class, class...>
+struct conditional_mapping;
+template <class T1, class T2, class... Rs, class... Ts>
+struct conditional_mapping<true, aux::type<T1, aux::inherit<Rs...>>, T2, Ts...> {
+  using type = unique_mappings_impl<aux::type<aux::inherit<T1>, extend_mapping_t<T2, Rs...>>, Ts...>;
+};
+template <class T1, class T2, class... Rs, class... Ts>
+struct conditional_mapping<false, aux::type<T1, aux::inherit<Rs...>>, T2, Ts...> {
+  using type =
+      unique_mappings_impl<aux::type<aux::inherit<T1, aux::type<typename T2::element_type>>, aux::inherit<T2, Rs...>>, Ts...>;
+};
+template <class T1, class T2, class... Rs, class... Ts>
+struct unique_mappings_impl<aux::type<T1, aux::inherit<Rs...>>, T2, Ts...>
+    : conditional_mapping<aux::is_base_of<aux::type<typename T2::element_type>, T1>::value, aux::type<T1, aux::inherit<Rs...>>,
+                          T2, Ts...>::type {};
+template <class T1, class Rs>
+struct unique_mappings_impl<aux::type<T1, Rs>> : aux::apply_t<aux::inherit, Rs> {};
+template <class... Ts>
+struct unique_mappings : unique_mappings_impl<aux::type<aux::none_type, aux::inherit<>>, Ts...> {};
+template <class T>
+struct unique_mappings<T> : aux::inherit<T> {};
+template <class, class...>
+struct mappings;
+template <class... Ts>
+struct mappings<aux::pool<Ts...>>
+    : unique_mappings_t<
+          event_mappings<typename Ts::event, aux::inherit<state_mappings<typename Ts::src_state, aux::type_list<Ts>>>>...> {};
+template <class T>
+using mappings_t = typename mappings<T>::type;
+template <class, class TUnexpected>
+transitions<TUnexpected> get_state_mapping_impl(...);
+template <class T, class, class... Ts>
+transitions<Ts...> get_state_mapping_impl(state_mappings<T, aux::type_list<Ts...>> *);
+template <class T, class TMappings, class TUnexpected>
+struct get_state_mapping {
+  using type = decltype(get_state_mapping_impl<T, TUnexpected>((TMappings *)0));
+};
+template <class S>
+transitions_sub<S> get_sub_state_mapping_impl(...);
+template <class T, class... Ts>
+transitions_sub<T, Ts...> get_sub_state_mapping_impl(state_mappings<T, aux::type_list<Ts...>> *);
+template <class T, class TMappings, class TUnexpected>
+struct get_state_mapping<sm<T>, TMappings, TUnexpected> {
+  using type = decltype(get_sub_state_mapping_impl<sm<T>>((TMappings *)0));
+};
+template <class T, class TMappings, class TUnexpected>
+using get_state_mapping_t = typename get_state_mapping<T, TMappings, TUnexpected>::type;
+template <class>
+transitions<aux::true_type> get_event_mapping_impl(...);
+template <class T, class TMappings>
+TMappings get_event_mapping_impl(event_mappings<T, TMappings> *);
+template <class T, class... T1Mappings, class... T2Mappings>
+unique_mappings_t<T1Mappings..., T2Mappings...> get_event_mapping_impl(event_mappings<T, aux::inherit<T1Mappings...>> *,
+                                                                       event_mappings<_, aux::inherit<T2Mappings...>> *);
+template <class T, class TMappings>
+struct get_event_mapping_impl_helper
+    : aux::conditional<aux::is_same<transitions<aux::true_type>, decltype(get_event_mapping_impl<_>((TMappings *)0))>::value,
+                       decltype(get_event_mapping_impl<T>((TMappings *)0)),
+                       decltype(get_event_mapping_impl<T>((TMappings *)0, (TMappings *)0))>::type {};
+template <class T, class TMappings>
+struct get_event_mapping_impl_helper<exception<T>, TMappings> : decltype(get_event_mapping_impl<exception<T>>((TMappings *)0)) {
+};
+template <class T1, class T2, class TMappings>
+struct get_event_mapping_impl_helper<unexpected_event<T1, T2>, TMappings>
+    : decltype(get_event_mapping_impl<unexpected_event<T1, T2>>((TMappings *)0)) {};
+template <class T1, class T2, class TMappings>
+struct get_event_mapping_impl_helper<on_entry<T1, T2>, TMappings>
+    : decltype(get_event_mapping_impl<on_entry<T1, T2>>((TMappings *)0)) {};
+template <class T1, class T2, class TMappings>
+struct get_event_mapping_impl_helper<on_exit<T1, T2>, TMappings>
+    : decltype(get_event_mapping_impl<on_exit<T1, T2>>((TMappings *)0)) {};
+template <class T, class TMappings>
+using get_event_mapping_t = get_event_mapping_impl_helper<T, TMappings>;
+}
+namespace back {
+namespace policies {
+struct dispatch_policy__ {};
+template <class T>
+struct dispatch : aux::pair<dispatch_policy__, T> {
+  using type = T;
+};
+struct jump_table {
+  template <int, class TMappings, class sm_impl, class State, class TEvent, class TDeps, class TSubs>
+  static bool dispatch(sm_impl &, State &, const TEvent &, TDeps &, TSubs &, const aux::type_list<> &) {
+    return false;
+  }
+  template <int, class TMappings, class sm_impl, class State, class TEvent, class TDeps, class TSubs, class... TStates>
+  static bool dispatch(sm_impl &self, State &current_state, const TEvent &event, TDeps &deps, TSubs &subs,
+                       const aux::type_list<TStates...> &) {
+    using dispatch_table_t = bool (*)(const TEvent &, sm_impl &, TDeps &, TSubs &, State &);
+    constexpr static dispatch_table_t dispatch_table[__BOOST_SML_ZERO_SIZE_ARRAY_CREATE(sizeof...(TStates))] = {
+        &get_state_mapping_t<TStates, TMappings, typename sm_impl::has_unexpected_events>::template execute<TEvent, sm_impl,
+                                                                                                            TDeps, TSubs>...};
+    return dispatch_table[current_state](event, self, deps, subs, current_state);
+  }
+};
+struct branch_stm {
+  template <int, class TMappings, class sm_impl, class State, class TEvent, class TDeps, class TSubs>
+  static bool dispatch(sm_impl &, State &, const TEvent &, TDeps &, TSubs &, const aux::type_list<> &) {
+    return false;
+  }
+  template <int N, class TMappings, class sm_impl, class State, class TEvent, class TDeps, class TSubs, class TState,
+            class... TStates>
+  static bool dispatch(sm_impl &self, State &current_state, const TEvent &event, TDeps &deps, TSubs &subs,
+                       const aux::type_list<TState, TStates...> &) {
+    return current_state == N
+               ? get_state_mapping_t<TState, TMappings, typename sm_impl::has_unexpected_events>::template execute<
+                     TEvent, sm_impl, TDeps, TSubs>(event, self, deps, subs, current_state)
+               : dispatch<N + 1, TMappings>(self, current_state, event, deps, subs, aux::type_list<TStates...>{});
+  }
+};
+struct switch_stm {
+  template <int, class TMappings, class sm_impl, class State, class TEvent, class TDeps, class TSubs>
+  static bool dispatch(sm_impl &, State &, const TEvent &, TDeps &, TSubs &, const aux::type_list<> &) {
+    return false;
+  }
+  template <int N, class TMappings, class sm_impl, class State, class TEvent, class TDeps, class TSubs, class TState,
+            class... TStates>
+  static bool dispatch(sm_impl &self, State &current_state, const TEvent &event, TDeps &deps, TSubs &subs,
+                       const aux::type_list<TState, TStates...> &) {
+    switch (current_state) {
+      case N:
+        return get_state_mapping_t<TState, TMappings, typename sm_impl::has_unexpected_events>::template execute<
+            TEvent, sm_impl, TDeps, TSubs>(event, self, deps, subs, current_state);
+      default:
+        return dispatch<N + 1, TMappings>(self, current_state, event, deps, subs, aux::type_list<TStates...>{});
+    }
+  }
+};
+#if defined(__cpp_fold_expressions)
+struct fold_expr {
+  template <class TMappings, auto... Ns, class sm_impl, class State, class TEvent, class TDeps, class TSubs, class... TStates>
+  static bool dispatch_impl(sm_impl &self, State &current_state, aux::index_sequence<Ns...>, const TEvent &event, TDeps &deps,
+                            TSubs &subs, const aux::type_list<TStates...> &) {
+    return ((current_state == Ns
+                 ? get_state_mapping_t<TStates, TMappings, typename sm_impl::has_unexpected_events>::template execute<
+                       TEvent, sm_impl, TDeps, TSubs>(event, self, deps, subs, current_state)
+                 : false) ||
+            ...);
+  }
+  template <int N, class TMappings, class sm_impl, class State, class TEvent, class TDeps, class TSubs, class... TStates>
+  static bool dispatch(sm_impl &self, State &current_state, const TEvent &event, TDeps &deps, TSubs &subs,
+                       const aux::type_list<TStates...> &states) {
+    return dispatch_impl<TMappings>(self, current_state, aux::make_index_sequence<sizeof...(TStates)>{}, event, deps, subs,
+                                    states);
+  }
+};
+#endif
+}
+}
+namespace back {
+template <class>
+class sm;
+template <class, class...>
+struct sm_policy;
+struct no_policy;
+namespace policies {
+struct logger_policy__ {};
+template <class T>
+struct logger : aux::pair<logger_policy__, logger<T>> {
+  using type = T;
+};
+template <class>
+struct get_state_name;
+template <class T>
+struct get_state_name<aux::string<T>> {
+  using type = aux::string<T>;
+};
+template <class T, class... Ts>
+struct get_state_name<aux::string<sm<sm_policy<T, Ts...>>>> {
+  using type = typename get_state_name<aux::string<sm_policy<T, Ts...>>>::type;
+};
+template <class T>
+struct get_state_name<aux::string<sm_policy<T>>> {
+  using type = aux::string<T>;
+};
+template <class T, class TName>
+struct get_state_name<aux::string<sm_policy<T, TName>>> {
+  using type = aux::string<T(typename TName::type)>;
+};
+template <class T>
+using get_state_name_t = typename get_state_name<T>::type;
+template <class, class TDeps, class TEvent>
+void log_process_event(const aux::type<no_policy> &, TDeps &, const TEvent &) {}
+template <class SM, class TLogger, class TDeps, class TEvent>
+void log_process_event(const aux::type<TLogger> &, TDeps &deps, const TEvent &event) {
+  return static_cast<aux::pool_type<TLogger &> &>(deps).value.template log_process_event<SM>(event);
+}
+template <class, class TDeps, class TSrcState, class TDstState>
+void log_state_change(const aux::type<no_policy> &, TDeps &, const TSrcState &, const TDstState &) {}
+template <class SM, class TLogger, class TDeps, class TSrcState, class TDstState>
+void log_state_change(const aux::type<TLogger> &, TDeps &deps, const TSrcState &, const TDstState &) {
+  return static_cast<aux::pool_type<TLogger &> &>(deps).value.template log_state_change<SM>(get_state_name_t<TSrcState>{},
+                                                                                            get_state_name_t<TDstState>{});
+}
+template <class, class TDeps, class TAction, class TEvent>
+void log_action(const aux::type<no_policy> &, TDeps &, const TAction &, const TEvent &) {}
+template <class SM, class TLogger, class TDeps, class TAction, class TEvent>
+void log_action(const aux::type<TLogger> &, TDeps &deps, const TAction &action, const TEvent &event) {
+  return static_cast<aux::pool_type<TLogger &> &>(deps).value.template log_action<SM>(action, event);
+}
+template <class SM, class TLogger, class TDeps, class TAction, class TEvent>
+void log_action(const aux::type<TLogger> &, TDeps &deps, const aux::zero_wrapper<TAction> &action, const TEvent &event) {
+  return static_cast<aux::pool_type<TLogger &> &>(deps).value.template log_action<SM>(action.get(), event);
+}
+template <class, class TDeps, class TGuard, class TEvent>
+void log_guard(const aux::type<no_policy> &, TDeps &, const TGuard &, const TEvent &, bool) {}
+template <class SM, class TLogger, class TDeps, class TGuard, class TEvent>
+void log_guard(const aux::type<TLogger> &, TDeps &deps, const TGuard &guard, const TEvent &event, bool result) {
+  return static_cast<aux::pool_type<TLogger &> &>(deps).value.template log_guard<SM>(guard, event, result);
+}
+template <class SM, class TLogger, class TDeps, class TGuard, class TEvent>
+void log_guard(const aux::type<TLogger> &, TDeps &deps, const aux::zero_wrapper<TGuard> &guard, const TEvent &event,
+               bool result) {
+  return static_cast<aux::pool_type<TLogger &> &>(deps).value.template log_guard<SM>(guard.get(), event, result);
+}
+}
+}
+namespace back {
+namespace policies {
+struct process_queue_policy__ {};
+template <template <class...> class T>
+struct process_queue : aux::pair<back::policies::process_queue_policy__, process_queue<T>> {
+  template <class U>
+  using rebind = T<U>;
+};
+}
+}
+namespace back {
+namespace policies {
+struct testing_policy__ {};
+struct testing : aux::pair<testing_policy__, testing> {};
+}
+}
+namespace back {
+namespace policies {
+struct thread_safety_policy__ {
+  auto create_lock() { return *this; }
+  __BOOST_SML_ZERO_SIZE_ARRAY(aux::byte);
+};
+template <class TLock>
+struct thread_safe : aux::pair<thread_safety_policy__, thread_safe<TLock>> {
+  using type = thread_safe;
+  auto create_lock() {
+    struct lock_guard {
+      explicit lock_guard(TLock &lock) : lock_{lock} { lock_.lock(); }
+      ~lock_guard() { lock_.unlock(); }
+      TLock &lock_;
+    };
+    return lock_guard{lock};
+  }
+  TLock lock;
+};
+}
+}
+namespace back {
+struct no_policy : policies::thread_safety_policy__ {
+  using type = no_policy;
+  template <class>
+  using rebind = no_policy;
+  template <class...>
+  using defer = no_policy;
+  __BOOST_SML_ZERO_SIZE_ARRAY(aux::byte);
+};
+template <class TDefault, class>
+TDefault get_policy(...);
+template <class, class T, class TPolicy>
+TPolicy get_policy(aux::pair<T, TPolicy> *);
+template <class SM, class... TPolicies>
+struct sm_policy {
+  static_assert(aux::is_same<aux::remove_reference_t<SM>, SM>::value, "SM type can't have qualifiers");
+#if defined(_MSC_VER)
+  using default_dispatch_policy = policies::jump_table;
+#elif defined(__clang__)
+  using default_dispatch_policy = policies::jump_table;
+#elif defined(__GNUC__)
+  using default_dispatch_policy = policies::branch_stm;
+#endif
+  using sm = SM;
+  using thread_safety_policy =
+      decltype(get_policy<no_policy, policies::thread_safety_policy__>((aux::inherit<TPolicies...> *)0));
+  using defer_queue_policy = decltype(get_policy<no_policy, policies::defer_queue_policy__>((aux::inherit<TPolicies...> *)0));
+  using process_queue_policy =
+      decltype(get_policy<no_policy, policies::process_queue_policy__>((aux::inherit<TPolicies...> *)0));
+  using logger_policy = decltype(get_policy<no_policy, policies::logger_policy__>((aux::inherit<TPolicies...> *)0));
+  using testing_policy = decltype(get_policy<no_policy, policies::testing_policy__>((aux::inherit<TPolicies...> *)0));
+  using dispatch_policy =
+      decltype(get_policy<default_dispatch_policy, policies::dispatch_policy__>((aux::inherit<TPolicies...> *)0));
+  template <class T>
+  using rebind = typename rebind_impl<T, TPolicies...>::type;
+};
+}
+namespace concepts {
+struct callable_fallback {
+  void operator()();
+};
+template <class T>
+aux::false_type test_callable(aux::non_type<void (callable_fallback::*)(), &T::operator()> *);
+template <class>
+aux::true_type test_callable(...);
+template <class, class T>
+struct callable
+    : decltype(test_callable<aux::inherit<aux::conditional_t<__is_class(T), T, aux::none_type>, callable_fallback>>(0)) {};
+}
+namespace concepts {
+template <class T>
+decltype(aux::declval<T>().operator()()) composable_impl(int);
+template <class>
+void composable_impl(...);
+template <class T>
+struct composable : aux::is<aux::pool, decltype(composable_impl<T>(0))> {};
+}
+#if !defined(BOOST_SML_DISABLE_EXCEPTIONS)
+#if !(defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND))
+#define BOOST_SML_DISABLE_EXCEPTIONS true
+#else
+#define BOOST_SML_DISABLE_EXCEPTIONS false
+#endif
+#endif
+namespace back {
+template <class TSM>
+struct sm_impl : aux::conditional_t<aux::is_empty<typename TSM::sm>::value, aux::none_type, typename TSM::sm> {
+  using sm_t = typename TSM::sm;
+  using thread_safety_t = typename TSM::thread_safety_policy::type;
+  template <class T>
+  using defer_queue_t = typename TSM::defer_queue_policy::template rebind<T>;
+  template <class T>
+  using process_queue_t = typename TSM::process_queue_policy::template rebind<T>;
+  using logger_t = typename TSM::logger_policy::type;
+  using dispatch_t = typename TSM::dispatch_policy;
+  using transitions_t = decltype(aux::declval<sm_t>().operator()());
+  using states_t = aux::apply_t<aux::unique_t, aux::apply_t<get_states, transitions_t>>;
+  using states_ids_t = aux::apply_t<aux::type_id, states_t>;
+  using initial_states_t = aux::apply_t<aux::unique_t, aux::apply_t<get_initial_states, transitions_t>>;
+  using initial_states_ids_t = aux::apply_t<aux::type_id, initial_states_t>;
+  using history_states_t = aux::apply_t<get_history_states, transitions_t>;
+  using has_history_states =
+      aux::integral_constant<bool, aux::size<initial_states_t>::value != aux::size<history_states_t>::value>;
+  using sub_internal_events_t = aux::apply_t<get_sub_internal_events, transitions_t>;
+  using events_t = aux::apply_t<aux::unique_t, aux::join_t<sub_internal_events_t, aux::apply_t<get_events, transitions_t>>>;
+  using events_ids_t = aux::apply_t<aux::inherit, events_t>;
+  using has_unexpected_events = typename aux::is_base_of<unexpected, aux::apply_t<aux::inherit, events_t>>::type;
+  using has_entry_exits = typename aux::is_base_of<entry_exit, aux::apply_t<aux::inherit, events_t>>::type;
+  using defer_t = defer_queue_t<aux::apply_t<queue_event, events_t>>;
+  using process_t = process_queue_t<aux::apply_t<queue_event, events_t>>;
+  using deps = aux::apply_t<merge_deps, transitions_t>;
+  using state_t = aux::conditional_t<(aux::size<states_t>::value > 0xFF), unsigned short, aux::byte>;
+  static constexpr auto regions = aux::size<initial_states_t>::value;
+  static_assert(regions > 0, "At least one initial state is required");
+#if !BOOST_SML_DISABLE_EXCEPTIONS
+  using exceptions = aux::apply_t<aux::unique_t, aux::apply_t<get_exceptions, events_t>>;
+  using has_exceptions = aux::integral_constant<bool, (aux::size<exceptions>::value > 0)>;
+#endif
+  struct mappings : mappings_t<transitions_t> {};
+  template <class TPool>
+  sm_impl(aux::init, const TPool &p) : sm_impl{p, aux::is_empty<sm_t>{}} {}
+  template <class TPool>
+  sm_impl(const TPool &p, aux::false_type) : sm_t{aux::try_get<sm_t>(&p)}, transitions_{(*this)()} {
+    initialize(typename sm_impl<TSM>::initial_states_t{});
+  }
+  template <class TPool>
+  sm_impl(const TPool &p, aux::true_type) : transitions_{aux::try_get<sm_t>(&p)()} {
+    initialize(typename sm_impl<TSM>::initial_states_t{});
+  }
+  template <class TEvent, class TDeps, class TSubs>
+  bool process_event(const TEvent &event, TDeps &deps, TSubs &subs) {
+    policies::log_process_event<sm_t>(aux::type<logger_t>{}, deps, event);
+#if BOOST_SML_DISABLE_EXCEPTIONS
+    const auto handled = process_event_impl<get_event_mapping_t<get_generic_t<TEvent>, mappings>>(
+        event, deps, subs, states_t{}, aux::make_index_sequence<regions>{});
+#else
+    const auto handled =
+        process_event_noexcept<get_event_mapping_t<get_generic_t<TEvent>, mappings>>(event, deps, subs, has_exceptions{});
+#endif
+    process_internal_events(anonymous{}, deps, subs);
+    process_defer_events(deps, subs, handled, aux::type<defer_queue_t<TEvent>>{}, events_t{});
+    process_queued_events(deps, subs, aux::type<process_queue_t<TEvent>>{}, events_t{});
+    return handled;
+  }
+  void initialize(const aux::type_list<> &) {}
+  template <class TState>
+  void initialize(const aux::type_list<TState> &) {
+    current_state_[0] = aux::get_id<state_t, TState>((states_ids_t *)0);
+  }
+  template <class... TStates>
+  void initialize(const aux::type_list<TStates...> &) {
+    auto region = 0;
+#if defined(__cpp_fold_expressions)
+    ((current_state_[region++] = aux::get_id<state_t, TStates>((states_ids_t *)0)), ...);
+#else
+    (void)aux::swallow{0, (current_state_[region++] = aux::get_id<state_t, TStates>((states_ids_t *)0), 0)...};
+#endif
+  }
+  template <class TDeps, class TSubs>
+  void start(TDeps &deps, TSubs &subs) {
+    process_internal_events(on_entry<_, initial>{}, deps, subs);
+    process_internal_events(anonymous{}, deps, subs);
+    process_queued_events(deps, subs, aux::type<process_queue_t<initial>>{}, events_t{});
+  }
+  template <class TEvent, class TDeps, class TSubs, class... Ts,
+            __BOOST_SML_REQUIRES(!aux::is_base_of<get_generic_t<TEvent>, events_ids_t>::value &&
+                                 !aux::is_base_of<get_mapped_t<TEvent>, events_ids_t>::value)>
+  bool process_internal_events(const TEvent &, TDeps &, TSubs &, Ts &&...) {
+    return false;
+  }
+  template <class TEvent, class TDeps, class TSubs,
+            __BOOST_SML_REQUIRES(aux::is_base_of<get_generic_t<TEvent>, events_ids_t>::value &&
+                                 !aux::is_base_of<get_mapped_t<TEvent>, events_ids_t>::value)>
+  bool process_internal_events(const TEvent &event, TDeps &deps, TSubs &subs) {
+    policies::log_process_event<sm_t>(aux::type<logger_t>{}, deps, event);
+#if BOOST_SML_DISABLE_EXCEPTIONS
+    return process_event_impl<get_event_mapping_t<get_generic_t<TEvent>, mappings>>(event, deps, subs, states_t{},
+                                                                                    aux::make_index_sequence<regions>{});
+#else
+    return process_event_noexcept<get_event_mapping_t<get_generic_t<TEvent>, mappings>>(event, deps, subs, has_exceptions{});
+#endif
+  }
+  template <class TEvent, class TDeps, class TSubs,
+            __BOOST_SML_REQUIRES(aux::is_base_of<get_mapped_t<TEvent>, events_ids_t>::value)>
+  bool process_internal_events(const TEvent &event, TDeps &deps, TSubs &subs) {
+    policies::log_process_event<sm_t>(aux::type<logger_t>{}, deps, event);
+#if BOOST_SML_DISABLE_EXCEPTIONS
+    return process_event_impl<get_event_mapping_t<get_mapped_t<TEvent>, mappings>>(event, deps, subs, states_t{},
+                                                                                   aux::make_index_sequence<regions>{});
+#else
+    return process_event_noexcept<get_event_mapping_t<get_mapped_t<TEvent>, mappings>>(event, deps, subs, has_exceptions{});
+#endif
+  }
+  template <class TEvent, class TDeps, class TSubs, class... Ts,
+            __BOOST_SML_REQUIRES(!aux::is_base_of<get_generic_t<TEvent>, events_ids_t>::value &&
+                                 !aux::is_base_of<get_mapped_t<TEvent>, events_ids_t>::value)>
+  bool process_internal_event(const TEvent &, TDeps &, TSubs &, Ts &&...) {
+    return false;
+  }
+  template <class TEvent, class TDeps, class TSubs,
+            __BOOST_SML_REQUIRES(aux::is_base_of<get_generic_t<TEvent>, events_ids_t>::value &&
+                                 !aux::is_base_of<get_mapped_t<TEvent>, events_ids_t>::value)>
+  bool process_internal_event(const TEvent &event, TDeps &deps, TSubs &subs, state_t &current_state) {
+    policies::log_process_event<sm_t>(aux::type<logger_t>{}, deps, event);
+#if BOOST_SML_DISABLE_EXCEPTIONS
+    return process_event_impl<get_event_mapping_t<get_generic_t<TEvent>, mappings>>(event, deps, subs, states_t{},
+                                                                                    current_state);
+#else
+    return process_event_noexcept<get_event_mapping_t<get_generic_t<TEvent>, mappings>>(event, deps, subs, current_state,
+                                                                                        has_exceptions{});
+#endif
+  }
+  template <class TEvent, class TDeps, class TSubs,
+            __BOOST_SML_REQUIRES(aux::is_base_of<get_mapped_t<TEvent>, events_ids_t>::value)>
+  bool process_internal_event(const TEvent &event, TDeps &deps, TSubs &subs, state_t &current_state) {
+    policies::log_process_event<sm_t>(aux::type<logger_t>{}, deps, event);
+#if BOOST_SML_DISABLE_EXCEPTIONS
+    return process_event_impl<get_event_mapping_t<get_mapped_t<TEvent>, mappings>>(event, deps, subs, states_t{},
+                                                                                   current_state);
+#else
+    return process_event_noexcept<get_event_mapping_t<get_mapped_t<TEvent>, mappings>>(event, deps, subs, current_state,
+                                                                                       has_exceptions{});
+#endif
+  }
+  template <class TMappings, class TEvent, class TDeps, class TSubs, class... TStates>
+  bool process_event_impl(const TEvent &event, TDeps &deps, TSubs &subs, const aux::type_list<TStates...> &states,
+                          aux::index_sequence<0>) {
+    const auto lock = thread_safety_.create_lock();
+    (void)lock;
+    return dispatch_t::template dispatch<0, TMappings>(*this, current_state_[0], event, deps, subs, states);
+  }
+  template <class TMappings, class TEvent, class TDeps, class TSubs, class... TStates, int... Ns>
+  bool process_event_impl(const TEvent &event, TDeps &deps, TSubs &subs, const aux::type_list<TStates...> &states,
+                          aux::index_sequence<Ns...>) {
+    const auto lock = thread_safety_.create_lock();
+    (void)lock;
+    auto handled = false;
+#if defined(__cpp_fold_expressions)
+    return ((handled |= dispatch_t::template dispatch<0, TMappings>(*this, current_state_[Ns], event, deps, subs, states)),
+            ...);
+#else
+    (void)aux::swallow{
+        0,
+        (handled |= dispatch_t::template dispatch<0, TMappings>(*this, current_state_[Ns], event, deps, subs, states), 0)...};
+#endif
+    return handled;
+  }
+  template <class TMappings, class TEvent, class TDeps, class TSubs, class... TStates>
+  bool process_event_impl(const TEvent &event, TDeps &deps, TSubs &subs, const aux::type_list<TStates...> &states,
+                          state_t &current_state) {
+    const auto lock = thread_safety_.create_lock();
+    (void)lock;
+    return dispatch_t::template dispatch<0, TMappings>(*this, current_state, event, deps, subs, states);
+  }
+#if !BOOST_SML_DISABLE_EXCEPTIONS
+  template <class TMappings, class TEvent, class TDeps, class TSubs>
+  bool process_event_noexcept(const TEvent &event, TDeps &deps, TSubs &subs, aux::false_type) noexcept {
+    return process_event_impl<TMappings>(event, deps, subs, states_t{}, aux::make_index_sequence<regions>{});
+  }
+  template <class TMappings, class TEvent, class TDeps, class TSubs>
+  bool process_event_noexcept(const TEvent &event, TDeps &deps, TSubs &subs, state_t &current_state, aux::false_type) noexcept {
+    return process_event_impl<TMappings>(event, deps, subs, states_t{}, current_state);
+  }
+  template <class TMappings, class TEvent, class TDeps, class TSubs>
+  bool process_event_noexcept(const TEvent &event, TDeps &deps, TSubs &subs, state_t &current_state, aux::true_type) noexcept {
+    try {
+      return process_event_impl<TMappings>(event, deps, subs, states_t{}, current_state);
+    } catch (...) {
+      return process_exception(deps, subs, exceptions{});
+    }
+  }
+  template <class TMappings, class TEvent, class TDeps, class TSubs>
+  bool process_event_noexcept(const TEvent &event, TDeps &deps, TSubs &subs, aux::true_type) {
+    try {
+      return process_event_impl<TMappings>(event, deps, subs, states_t{}, aux::make_index_sequence<regions>{});
+    } catch (...) {
+      return process_exception(deps, subs, exceptions{});
+    }
+  }
+  template <class TDeps, class TSubs>
+  bool process_exception(TDeps &deps, TSubs &subs, const aux::type_list<> &) {
+    return process_internal_events(exception<_>{}, deps, subs);
+  }
+  template <class TDeps, class TSubs, class E, class... Es>
+  bool process_exception(TDeps &deps, TSubs &subs, const aux::type_list<E, Es...> &) {
+    try {
+      throw;
+    } catch (const typename E::type &e) {
+      return process_internal_events(E{e}, deps, subs);
+    } catch (...) {
+      return process_exception(deps, subs, aux::type_list<Es...>{});
+    }
+  }
+#endif
+  template <class TDeps, class TSubs, class... TEvents>
+  void process_defer_events(TDeps &, TSubs &, const bool, const aux::type<no_policy> &, const aux::type_list<TEvents...> &) {}
+  template <class TDeps, class TSubs, class TEvent>
+  bool process_event_no_defer(TDeps &deps, TSubs &subs, const void *data) {
+    const auto &event = *static_cast<const TEvent *>(data);
+    policies::log_process_event<sm_t>(aux::type<logger_t>{}, deps, event);
+#if BOOST_SML_DISABLE_EXCEPTIONS
+    const auto handled = process_event_impl<get_event_mapping_t<TEvent, mappings>>(event, deps, subs, states_t{},
+                                                                                   aux::make_index_sequence<regions>{});
+#else
+    const auto handled = process_event_noexcept<get_event_mapping_t<TEvent, mappings>>(event, deps, subs, has_exceptions{});
+#endif
+    if (handled) {
+      defer_.pop();
+    }
+    return handled;
+  }
+  template <class TDeps, class TSubs, class TDeferQueue, class... TEvents>
+  void process_defer_events(TDeps &deps, TSubs &subs, const bool handled, const aux::type<TDeferQueue> &,
+                            const aux::type_list<TEvents...> &) {
+    if (handled) {
+      auto size = defer_.size();
+      using dispatch_table_t = bool (sm_impl::*)(TDeps &, TSubs &, const void *);
+      const static dispatch_table_t dispatch_table[__BOOST_SML_ZERO_SIZE_ARRAY_CREATE(sizeof...(TEvents))] = {
+          &sm_impl::process_event_no_defer<TDeps, TSubs, TEvents>...};
+      while (size-- && (this->*dispatch_table[defer_.front().id])(deps, subs, defer_.front().data))
+        ;
+    }
+  }
+  template <class TDeps, class TSubs, class... TEvents>
+  void process_queued_events(TDeps &, TSubs &, const aux::type<no_policy> &, const aux::type_list<TEvents...> &) {}
+  template <class TDeps, class TSubs, class TEvent>
+  bool process_event_no_queue(TDeps &deps, TSubs &subs, const void *data) {
+    const auto &event = *static_cast<const TEvent *>(data);
+    policies::log_process_event<sm_t>(aux::type<logger_t>{}, deps, event);
+#if BOOST_SML_DISABLE_EXCEPTIONS
+    return process_event_impl<get_event_mapping_t<TEvent, mappings>>(event, deps, subs, states_t{},
+                                                                     aux::make_index_sequence<regions>{});
+#else
+    return process_event_noexcept<get_event_mapping_t<TEvent, mappings>>(event, deps, subs, has_exceptions{});
+#endif
+  }
+  template <class TDeps, class TSubs, class TDeferQueue, class... TEvents>
+  void process_queued_events(TDeps &deps, TSubs &subs, const aux::type<TDeferQueue> &, const aux::type_list<TEvents...> &) {
+    using dispatch_table_t = bool (sm_impl::*)(TDeps &, TSubs &, const void *);
+    const static dispatch_table_t dispatch_table[__BOOST_SML_ZERO_SIZE_ARRAY_CREATE(sizeof...(TEvents))] = {
+        &sm_impl::process_event_no_queue<TDeps, TSubs, TEvents>...};
+    while (!process_.empty()) {
+      (this->*dispatch_table[process_.front().id])(deps, subs, process_.front().data);
+      process_.pop();
+    }
+  }
+  template <class TVisitor, class... TStates>
+  void visit_current_states(const TVisitor &visitor, const aux::type_list<TStates...> &, aux::index_sequence<0>) const {
+    using dispatch_table_t = void (*)(const TVisitor &);
+    const static dispatch_table_t dispatch_table[__BOOST_SML_ZERO_SIZE_ARRAY_CREATE(sizeof...(TStates))] = {
+        &sm_impl::visit_state<TVisitor, TStates>...};
+    dispatch_table[current_state_[0]](visitor);
+  }
+  template <class TVisitor, class... TStates, int... Ns>
+  void visit_current_states(const TVisitor &visitor, const aux::type_list<TStates...> &, aux::index_sequence<Ns...>) const {
+    using dispatch_table_t = void (*)(const TVisitor &);
+    const static dispatch_table_t dispatch_table[__BOOST_SML_ZERO_SIZE_ARRAY_CREATE(sizeof...(TStates))] = {
+        &sm_impl::visit_state<TVisitor, TStates>...};
+#if defined(__cpp_fold_expressions)
+    (dispatch_table[current_state_[Ns]](visitor), ...);
+#else
+    (void)aux::swallow{0, (dispatch_table[current_state_[Ns]](visitor), 0)...};
+#endif
+  }
+  template <class TVisitor, class TState>
+  static void visit_state(const TVisitor &visitor) {
+    visitor(aux::string<TState>{});
+  }
+  bool is_terminated() const { return is_terminated_impl(aux::make_index_sequence<regions>{}); }
+  bool is_terminated_impl(aux::index_sequence<0>) const {
+    return current_state_[0] == aux::get_id<state_t, terminate_state>((states_ids_t *)0);
+  }
+  template <int... Ns>
+  bool is_terminated_impl(aux::index_sequence<Ns...>) const {
+#if defined(__cpp_fold_expressions)
+    return ((current_state_[Ns] == aux::get_id<state_t, terminate_state>((states_ids_t *)0)) && ...);
+#else
+    auto result = true;
+    (void)aux::swallow{
+        0, (current_state_[Ns] == aux::get_id<state_t, terminate_state>((states_ids_t *)0) ? result : (result = false))...};
+    return result;
+#endif
+  }
+  transitions_t transitions_;
+  state_t current_state_[regions];
+  thread_safety_t thread_safety_;
+  defer_t defer_;
+  process_t process_;
+};
+template <class TSM>
+class sm {
+  using sm_t = typename TSM::sm;
+  using logger_t = typename TSM::logger_policy::type;
+  using logger_dep_t =
+      aux::conditional_t<aux::is_same<no_policy, logger_t>::value, aux::type_list<>, aux::type_list<logger_t &>>;
+  using transitions_t = decltype(aux::declval<sm_t>().operator()());
+  static_assert(concepts::composable<sm_t>::value, "Composable constraint is not satisfied!");
+
+ public:
+  using states = aux::apply_t<aux::unique_t, aux::apply_t<get_states, transitions_t>>;
+  using state_machines = aux::apply_t<get_sub_sms, states>;
+  using events = aux::apply_t<aux::unique_t, aux::apply_t<get_all_events, transitions_t>>;
+  using transitions = aux::apply_t<aux::type_list, transitions_t>;
+
+ private:
+  using sm_all_t = aux::apply_t<get_non_empty_t, aux::join_t<aux::type_list<sm_t>, aux::apply_t<get_sm_t, state_machines>>>;
+  using sub_sms_t = aux::apply_t<aux::pool, typename convert_to_sm<TSM, aux::apply_t<get_sub_sms, states>>::type>;
+  using deps = aux::apply_t<merge_deps, transitions_t>;
+  using deps_t =
+      aux::apply_t<aux::pool,
+                   aux::apply_t<aux::unique_t, aux::join_t<deps, sm_all_t, logger_dep_t, aux::apply_t<merge_deps, sub_sms_t>>>>;
+  struct events_ids : aux::apply_t<aux::inherit, events> {};
+
+ public:
+  sm() : deps_{aux::init{}, aux::pool<>{}}, sub_sms_{aux::pool<>{}} { aux::get<sm_impl<TSM>>(sub_sms_).start(deps_, sub_sms_); }
+  template <class... TDeps, __BOOST_SML_REQUIRES((sizeof...(TDeps) > 0) && aux::is_unique_t<TDeps...>::value)>
+  explicit sm(TDeps &&... deps) : deps_{aux::init{}, aux::pool<TDeps...>{deps...}}, sub_sms_{aux::pool<TDeps...>{deps...}} {
+    aux::get<sm_impl<TSM>>(sub_sms_).start(deps_, sub_sms_);
+  }
+  sm(aux::init, deps_t &deps) : deps_{deps}, sub_sms_{deps} { aux::get<sm_impl<TSM>>(sub_sms_).start(deps_, sub_sms_); }
+  sm(sm &&other) : deps_{other.deps_}, sub_sms_{other.deps_} {}
+  sm(const sm &) = delete;
+  sm &operator=(const sm &) = delete;
+  template <class TEvent, __BOOST_SML_REQUIRES(aux::is_base_of<TEvent, events_ids>::value)>
+  void process_event(const TEvent &event) {
+    aux::get<sm_impl<TSM>>(sub_sms_).process_event(event, deps_, sub_sms_);
+  }
+  template <class TEvent, __BOOST_SML_REQUIRES(!aux::is_base_of<TEvent, events_ids>::value)>
+  void process_event(const TEvent &event) {
+    aux::get<sm_impl<TSM>>(sub_sms_).process_event(unexpected_event<_, TEvent>{event}, deps_, sub_sms_);
+  }
+  template <class T = aux::identity<sm_t>, class TVisitor, __BOOST_SML_REQUIRES(concepts::callable<void, TVisitor>::value)>
+  void visit_current_states(const TVisitor &visitor) const {
+    using type = typename T::type;
+    using sm_impl_t = sm_impl<typename TSM::template rebind<type>>;
+    using states_t = typename sm_impl_t::states_t;
+    constexpr auto regions = sm_impl_t::regions;
+    aux::cget<sm_impl_t>(sub_sms_).visit_current_states(visitor, states_t{}, aux::make_index_sequence<regions>{});
+  }
+  template <class T = aux::identity<sm_t>, class TState>
+  bool is(const TState &) const {
+    using type = typename T::type;
+    using sm_impl_t = sm_impl<typename TSM::template rebind<type>>;
+    using state_t = typename sm_impl_t::state_t;
+    using states_ids_t = typename sm_impl_t::states_ids_t;
+    return aux::get_id<state_t, typename TState::type>((states_ids_t *)0) == aux::cget<sm_impl_t>(sub_sms_).current_state_[0];
+  }
+  template <class T = aux::identity<sm_t>, template <class...> class TState>
+  bool is(const TState<terminate_state> &) const {
+    using type = typename T::type;
+    using sm_impl_t = sm_impl<typename TSM::template rebind<type>>;
+    using state_t = typename sm_impl_t::state_t;
+    using states_ids_t = typename sm_impl_t::states_ids_t;
+    auto result = false;
+    visit_current_states<T>([&](auto state) {
+      (void)state;
+      result |= (aux::get_id<state_t, terminate_state>((states_ids_t *)0) ==
+                 aux::get_id<state_t, typename decltype(state)::type>((states_ids_t *)0));
+    });
+    return result;
+  }
+  template <class T = aux::identity<sm_t>, class... TStates,
+            __BOOST_SML_REQUIRES(sizeof...(TStates) == sm_impl<typename TSM::template rebind<typename T::type>>::regions)>
+  bool is(const TStates &...) const {
+    using type = typename T::type;
+    using sm_impl_t = sm_impl<typename TSM::template rebind<type>>;
+    using states_ids_t = typename sm_impl_t::states_ids_t;
+    using state_t = typename sm_impl_t::state_t;
+    auto result = true;
+    auto i = 0;
+    state_t state_ids[] = {aux::get_id<state_t, typename TStates::type>((states_ids_t *)0)...};
+    visit_current_states<T>([&](auto state) {
+      (void)state;
+      result &= (aux::get_id<state_t, typename decltype(state)::type>((states_ids_t *)0) == state_ids[i++]);
+    });
+    return result;
+  }
+  template <class T = aux::identity<sm_t>, class... TStates,
+            __BOOST_SML_REQUIRES(!aux::is_same<no_policy, typename TSM::testing_policy>::value && aux::always<T>::value)>
+  void set_current_states(const TStates &...) {
+    using type = typename T::type;
+    using sm_impl_t = sm_impl<typename TSM::template rebind<type>>;
+    using states_ids_t = typename sm_impl_t::states_ids_t;
+    using state_t = typename sm_impl_t::state_t;
+    auto &sm = aux::get<sm_impl<TSM>>(sub_sms_);
+    auto region = 0;
+#if defined(__cpp_fold_expressions)
+    ((sm.current_state_[region++] = aux::get_id<state_t, typename TStates::type>((states_ids_t *)0)), ...);
+#else
+    (void)aux::swallow{0,
+                       (sm.current_state_[region++] = aux::get_id<state_t, typename TStates::type>((states_ids_t *)0), 0)...};
+#endif
+  }
+  template <class T>
+  operator T &() {
+    return aux::get<sm_impl<typename TSM::template rebind<T>>>(sub_sms_);
+  }
+  template <class T>
+  operator const T &() {
+    return aux::cget<sm_impl<typename TSM::template rebind<T>>>(sub_sms_);
+  }
+
+ private:
+  deps_t deps_;
+  sub_sms_t sub_sms_;
+};
+}
+namespace front {
+struct operator_base {};
+struct action_base {};
+template <class, class>
+aux::type_list<action_base> args1__(...);
+template <class T, class E>
+auto args1__(int) -> aux::function_traits_t<decltype(&T::operator())>;
+template <class T, class E>
+auto args__(int) -> aux::function_traits_t<decltype(&T::__BOOST_SML_TEMPLATE_KEYWORD operator()<back::get_event_t<E>>)>;
+template <class T, class E>
+auto args__(...) -> decltype(args1__<T, E>(0));
+template <class T, class E>
+using args_t = decltype(args__<T, E>(0));
+template <class T, class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<T> &, const TEvent &, TSM &, TDeps &deps) {
+  return aux::get<T>(deps);
+}
+template <class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<TEvent> &, const TEvent &event, TSM &, TDeps &) {
+  return event;
+}
+template <class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<const TEvent &> &, const TEvent &event, TSM &, TDeps &) {
+  return event;
+}
+template <class T, class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<const TEvent &> &, const back::unexpected_event<T, TEvent> &event, TSM &, TDeps &) {
+  return event.event_;
+}
+template <class T, class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<const TEvent &> &, const back::on_entry<T, TEvent> &event, TSM &, TDeps &) {
+  return event.event_;
+}
+template <class T, class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<const TEvent &> &, const back::on_exit<T, TEvent> &event, TSM &, TDeps &) {
+  return event.event_;
+}
+template <class T, class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<const TEvent &> &, const back::exception<T, TEvent> &event, TSM &, TDeps &) {
+  return event.exception_;
+}
+template <class... TEvents, class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<back::defer<TEvents...>> &, const TEvent, TSM &sm, TDeps &) {
+  return back::defer<TEvents...>{sm.defer_};
+}
+template <class... TEvents, class TEvent, class TSM, class TDeps>
+decltype(auto) get_arg(const aux::type<back::process<TEvents...>> &, const TEvent, TSM &sm, TDeps &) {
+  return back::process<TEvents...>{sm.process_};
+}
+template <class, class, class>
+struct call;
+template <class TEvent>
+struct call<TEvent, aux::type_list<>, back::no_policy> {
+  template <class T, class TSM, class TDeps, class TSubs>
+  static auto execute(T object, const TEvent &, TSM &, TDeps &, TSubs &) {
+    return object();
+  }
+};
+template <class TEvent, class TLogger>
+struct call<TEvent, aux::type_list<>, TLogger> {
+  template <class T, class TSM, class TDeps, class TSubs>
+  static auto execute(T object, const TEvent &event, TSM &, TDeps &deps, TSubs &) {
+    using result_type = decltype(object());
+    return execute_impl<typename TSM::sm_t>(aux::type<result_type>{}, object, event, deps);
+  }
+  template <class TSM, class T, class TDeps>
+  static auto execute_impl(const aux::type<bool> &, T object, const TEvent &event, TDeps &deps) {
+    const auto result = object();
+    back::policies::log_guard<TSM>(aux::type<TLogger>{}, deps, object, event, result);
+    return result;
+  }
+  template <class TSM, class T, class TDeps>
+  static auto execute_impl(const aux::type<void> &, T object, const TEvent &event, TDeps &deps) {
+    back::policies::log_action<TSM>(aux::type<TLogger>{}, deps, object, event);
+    object();
+  }
+};
+template <class TEvent>
+struct call<TEvent, aux::type_list<TEvent>, back::no_policy> {
+  template <class T, class TSM, class TDeps, class TSubs>
+  static auto execute(T object, const TEvent &event, TSM &, TDeps &, TSubs &) {
+    return object(event);
+  }
+};
+template <class TEvent, class TLogger>
+struct call<TEvent, aux::type_list<TEvent>, TLogger> {
+  template <class T, class TSM, class TDeps, class TSubs>
+  static auto execute(T object, const TEvent &event, TSM &, TDeps &deps, TSubs &) {
+    using result_type = decltype(object(event));
+    return execute_impl<typename TSM::sm_t>(aux::type<result_type>{}, object, event, deps);
+  }
+  template <class TSM, class T, class TDeps>
+  static auto execute_impl(const aux::type<bool> &, T object, const TEvent &event, TDeps &deps) {
+    const auto result = object(event);
+    back::policies::log_guard<TSM>(aux::type<TLogger>{}, deps, object, event, result);
+    return result;
+  }
+  template <class TSM, class T, class TDeps>
+  static auto execute_impl(const aux::type<void> &, T object, const TEvent &event, TDeps &deps) {
+    back::policies::log_action<TSM>(aux::type<TLogger>{}, deps, object, event);
+    object(event);
+  }
+};
+template <class TEvent>
+struct call<TEvent, aux::type_list<action_base>, back::no_policy> {
+  template <class T, class TSM, class TDeps, class TSubs>
+  static auto execute(T object, const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+    return object(event, sm, deps, subs);
+  }
+};
+template <class TEvent, class TLogger>
+struct call<TEvent, aux::type_list<action_base>, TLogger> {
+  template <class T, class TSM, class TDeps, class TSubs>
+  static auto execute(T object, const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+    return object(event, sm, deps, subs);
+  }
+};
+template <class TEvent, class... Ts>
+struct call<TEvent, aux::type_list<Ts...>, back::no_policy> {
+  template <class T, class TSM, class TDeps, class TSubs>
+  static auto execute(T object, const TEvent &event, TSM &sm, TDeps &deps, TSubs &) {
+    return object(get_arg(aux::type<Ts>{}, event, sm, deps)...);
+  }
+};
+template <class TEvent, class... Ts, class TLogger>
+struct call<TEvent, aux::type_list<Ts...>, TLogger> {
+  template <class T, class TSM, class TDeps, class TSubs>
+  static auto execute(T object, const TEvent &event, TSM &sm, TDeps &deps, TSubs &) {
+    using result_type = decltype(object(get_arg(aux::type<Ts>{}, event, sm, deps)...));
+    return execute_impl<typename TSM::sm_t>(aux::type<result_type>{}, object, event, sm, deps);
+  }
+  template <class TSM, class T, class SM, class TDeps>
+  static auto execute_impl(const aux::type<bool> &, T object, const TEvent &event, SM &sm, TDeps &deps) {
+    const auto result = object(get_arg(aux::type<Ts>{}, event, sm, deps)...);
+    back::policies::log_guard<TSM>(aux::type<TLogger>{}, deps, object, event, result);
+    return result;
+  }
+  template <class TSM, class T, class SM, class TDeps>
+  static auto execute_impl(const aux::type<void> &, T object, const TEvent &event, SM &sm, TDeps &deps) {
+    back::policies::log_action<TSM>(aux::type<TLogger>{}, deps, object, event);
+    object(get_arg(aux::type<Ts>{}, event, sm, deps)...);
+  }
+};
+template <class... Ts>
+class seq_ : operator_base {
+ public:
+  explicit seq_(Ts... ts) : a(ts...) {}
+  template <class TEvent, class TSM, class TDeps, class TSubs>
+  void operator()(const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+    for_all(aux::make_index_sequence<sizeof...(Ts)>{}, event, sm, deps, subs);
+  }
+
+ private:
+  template <int... Ns, class TEvent, class TSM, class TDeps, class TSubs>
+  void for_all(const aux::index_sequence<Ns...> &, const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+#if defined(__cpp_fold_expressions)
+    (call<TEvent, args_t<Ts, TEvent>, typename TSM::logger_t>::execute(aux::get_by_id<Ns>(&a), event, sm, deps, subs), ...);
+#else
+    (void)aux::swallow{
+        0, (call<TEvent, args_t<Ts, TEvent>, typename TSM::logger_t>::execute(aux::get_by_id<Ns>(&a), event, sm, deps, subs),
+            0)...};
+#endif
+  }
+  aux::tuple<Ts...> a;
+};
+template <class... Ts>
+class and_ : operator_base {
+ public:
+  explicit and_(Ts... ts) : g(ts...) {}
+  template <class TEvent, class TSM, class TDeps, class TSubs>
+  auto operator()(const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+    return for_all(aux::make_index_sequence<sizeof...(Ts)>{}, event, sm, deps, subs);
+  }
+
+ private:
+  template <int... Ns, class TEvent, class TSM, class TDeps, class TSubs>
+  auto for_all(const aux::index_sequence<Ns...> &, const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+#if defined(__cpp_fold_expressions)
+    return (call<TEvent, args_t<Ts, TEvent>, typename TSM::logger_t>::execute(aux::get_by_id<Ns>(&g), event, sm, deps, subs) &&
+            ...);
+#else
+    auto result = true;
+    (void)aux::swallow{0, (result && call<TEvent, args_t<Ts, TEvent>, typename TSM::logger_t>::execute(aux::get_by_id<Ns>(&g),
+                                                                                                       event, sm, deps, subs)
+                               ? result
+                               : (result = false))...};
+    return result;
+#endif
+  }
+  aux::tuple<Ts...> g;
+};
+template <class... Ts>
+class or_ : operator_base {
+ public:
+  explicit or_(Ts... ts) : g(ts...) {}
+  template <class TEvent, class TSM, class TDeps, class TSubs>
+  auto operator()(const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+    return for_all(aux::make_index_sequence<sizeof...(Ts)>{}, event, sm, deps, subs);
+  }
+
+ private:
+  template <int... Ns, class TEvent, class TSM, class TDeps, class TSubs>
+  auto for_all(const aux::index_sequence<Ns...> &, const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+#if defined(__cpp_fold_expressions)
+    return (call<TEvent, args_t<Ts, TEvent>, typename TSM::logger_t>::execute(aux::get_by_id<Ns>(&g), event, sm, deps, subs) ||
+            ...);
+#else
+    auto result = false;
+    (void)aux::swallow{0, (result || call<TEvent, args_t<Ts, TEvent>, typename TSM::logger_t>::execute(aux::get_by_id<Ns>(&g),
+                                                                                                       event, sm, deps, subs)
+                               ? (result = true)
+                               : result)...};
+    return result;
+#endif
+  }
+  aux::tuple<Ts...> g;
+};
+template <class T>
+class not_ : operator_base {
+ public:
+  explicit not_(T t) : g(t) {}
+  template <class TEvent, class TSM, class TDeps, class TSubs>
+  auto operator()(const TEvent &event, TSM &sm, TDeps &deps, TSubs &subs) {
+    return !call<TEvent, args_t<T, TEvent>, typename TSM::logger_t>::execute(g, event, sm, deps, subs);
+  }
+
+ private:
+  T g;
+};
+}
+template <class T, __BOOST_SML_REQUIRES(concepts::callable<bool, T>::value)>
+auto operator!(const T &t) {
+  return front::not_<aux::zero_wrapper<T>>(aux::zero_wrapper<T>{t});
+}
+template <class T1, class T2, __BOOST_SML_REQUIRES(concepts::callable<bool, T1>::value &&concepts::callable<bool, T2>::value)>
+auto operator&&(const T1 &t1, const T2 &t2) {
+  return front::and_<aux::zero_wrapper<T1>, aux::zero_wrapper<T2>>(aux::zero_wrapper<T1>{t1}, aux::zero_wrapper<T2>{t2});
+}
+template <class T1, class T2, __BOOST_SML_REQUIRES(concepts::callable<bool, T1>::value &&concepts::callable<bool, T2>::value)>
+auto operator||(const T1 &t1, const T2 &t2) {
+  return front::or_<aux::zero_wrapper<T1>, aux::zero_wrapper<T2>>(aux::zero_wrapper<T1>{t1}, aux::zero_wrapper<T2>{t2});
+}
+template <class T1, class T2, __BOOST_SML_REQUIRES(concepts::callable<void, T1>::value &&concepts::callable<void, T2>::value)>
+auto operator,(const T1 &t1, const T2 &t2) {
+  return front::seq_<aux::zero_wrapper<T1>, aux::zero_wrapper<T2>>(aux::zero_wrapper<T1>{t1}, aux::zero_wrapper<T2>{t2});
+}
+namespace front {
+namespace actions {
+struct defer : action_base {
+  template <class TEvent, class TSM, class TDeps, class TSubs>
+  void operator()(const TEvent &event, TSM &sm, TDeps &, TSubs &) {
+    sm.defer_.push(event);
+  }
+};
+}
+}
+using testing = back::policies::testing;
+template <class T>
+using logger = back::policies::logger<T>;
+template <class T>
+using thread_safe = back::policies::thread_safe<T>;
+template <class T>
+using dispatch = back::policies::dispatch<T>;
+template <template <class...> class T>
+using defer_queue = back::policies::defer_queue<T>;
+template <template <class...> class T>
+using process_queue = back::policies::process_queue<T>;
+#if defined(_MSC_VER)
+template <class T, class... TPolicies, class T__ = aux::remove_reference_t<decltype(aux::declval<T>())>>
+using sm = back::sm<back::sm_policy<T__, TPolicies...>>;
+#else
+template <class T, class... TPolicies>
+using sm = back::sm<back::sm_policy<T, TPolicies...>>;
+#endif
+namespace concepts {
+aux::false_type transitional_impl(...);
+template <class T>
+auto transitional_impl(T &&t) -> aux::always<typename T::dst_state, typename T::src_state, typename T::event, typename T::deps,
+                                             decltype(T::initial), decltype(T::history)>;
+template <class T>
+struct transitional : decltype(transitional_impl(aux::declval<T>())) {};
+}
+namespace front {
+namespace actions {
+struct process {
+  template <class TEvent>
+  class process_impl : public action_base {
+   public:
+    explicit process_impl(const TEvent &event) : event(event) {}
+    template <class T, class TSM, class TDeps, class TSubs>
+    void operator()(const T &, TSM &sm, TDeps &, TSubs &) {
+      sm.process_.push(event);
+    }
+
+   private:
+    TEvent event;
+  };
+  template <class TEvent>
+  auto operator()(const TEvent &event) {
+    return process_impl<TEvent>{event};
+  }
+};
+}
+}
+namespace front {
+template <class, class>
+struct transition_eg;
+template <class, class>
+struct transition_ea;
+template <class TEvent>
+struct event {
+  template <class T, __BOOST_SML_REQUIRES(concepts::callable<bool, T>::value)>
+  auto operator[](const T &t) const {
+    return transition_eg<event, aux::zero_wrapper<T>>{*this, aux::zero_wrapper<T>{t}};
+  }
+  template <class T, __BOOST_SML_REQUIRES(concepts::callable<void, T>::value)>
+  auto operator/(const T &t) const {
+    return transition_ea<event, aux::zero_wrapper<T>>{*this, aux::zero_wrapper<T>{t}};
+  }
+  auto operator()() const { return TEvent{}; }
+};
+}
+namespace front {
+struct initial_state {};
+struct history_state {};
+template <class...>
+struct transition;
+template <class, class>
+struct transition_sa;
+template <class, class>
+struct transition_sg;
+template <class, class>
+struct transition_eg;
+template <class>
+struct state;
+template <class TState>
+struct state_impl {
+  template <class T>
+  auto operator<=(const T &t) const {
+    return transition<TState, T>{static_cast<const TState &>(*this), t};
+  }
+  template <class T>
+  auto operator+(const T &t) const {
+    return transition<TState, T>{static_cast<const TState &>(*this), t};
+  }
+  template <class T, __BOOST_SML_REQUIRES(concepts::callable<bool, T>::value)>
+  auto operator[](const T &t) const {
+    return transition_sg<TState, aux::zero_wrapper<T>>{static_cast<const TState &>(*this), aux::zero_wrapper<T>{t}};
+  }
+  template <class T, __BOOST_SML_REQUIRES(concepts::callable<void, T>::value)>
+  auto operator/(const T &t) const {
+    return transition_sa<TState, aux::zero_wrapper<T>>{static_cast<const TState &>(*this), aux::zero_wrapper<T>{t}};
+  }
+};
+template <class TState>
+struct state : state_impl<state<TState>> {
+  using type = TState;
+  static constexpr auto initial = false;
+  static constexpr auto history = false;
+  auto operator*() const { return state<TState(initial_state)>{}; }
+  auto operator()(const initial_state &) const { return state<TState(initial_state)>{}; }
+  auto operator()(const history_state &) const { return state<TState(history_state)>{}; }
+  template <class... Ts>
+  auto operator()(const state<Ts> &...) const {
+    return state<TState(Ts...)>{};
+  }
+  template <class T>
+  auto operator=(const T &t) const {
+    return transition<T, state>{t, *this};
+  }
+  template <class T>
+  auto sm() const {
+    return state<back::sm<back::sm_policy<T, aux::identity<TState>>>>{};
+  }
+};
+template <class TState>
+struct state<TState(initial_state)> : state_impl<state<TState(initial_state)>> {
+  using type = TState;
+  static constexpr auto initial = true;
+  static constexpr auto history = false;
+  template <class T>
+  auto operator=(const T &t) const {
+    return transition<T, state>{t, *this};
+  }
+};
+template <class TState>
+struct state<TState(history_state)> : state_impl<state<TState(history_state)>> {
+  using type = TState;
+  static constexpr auto initial = true;
+  static constexpr auto history = true;
+  template <class T>
+  auto operator=(const T &t) const {
+    return transition<T, state>{t, *this};
+  }
+};
+#if defined(_MSC_VER)
+template <class T, class T__ = aux::remove_reference_t<decltype(aux::declval<T>())>, class = void>
+struct state_sm {
+  using type = state<T>;
+};
+template <class T, class T__>
+struct state_sm<T, T__, aux::enable_if_t<concepts::composable<T__>::value>> {
+  using type = state<back::sm<back::sm_policy<T__>>>;
+};
+#else
+template <class T, class = void>
+struct state_sm {
+  using type = state<T>;
+};
+template <class T>
+struct state_sm<T, aux::enable_if_t<concepts::composable<T>::value>> {
+  using type = state<back::sm<back::sm_policy<T>>>;
+};
+#endif
+}
+namespace front {
+struct internal {};
+template <class, class>
+struct ignore;
+template <class E, class... Ts>
+struct ignore<E, aux::type_list<Ts...>> {
+  template <class T>
+  struct non_events {
+    using type =
+        aux::conditional_t<aux::is_same<back::get_event_t<E>, aux::remove_const_t<aux::remove_reference_t<T>>>::value ||
+                               aux::is_same<T, action_base>::value,
+                           aux::type_list<>, aux::type_list<T>>;
+  };
+  using type = aux::join_t<typename non_events<Ts>::type...>;
+};
+template <class T, class E, class = void>
+struct get_deps {
+  using type = typename ignore<E, args_t<T, E>>::type;
+};
+template <class T, class E>
+using get_deps_t = typename get_deps<T, E>::type;
+template <template <class...> class T, class... Ts, class E>
+struct get_deps<T<Ts...>, E, aux::enable_if_t<aux::is_base_of<operator_base, T<Ts...>>::value>> {
+  using type = aux::join_t<get_deps_t<Ts, E>...>;
+};
+struct always {
+  bool operator()() const { return true; }
+  __BOOST_SML_ZERO_SIZE_ARRAY(aux::byte);
+};
+struct none {
+  void operator()() {}
+  __BOOST_SML_ZERO_SIZE_ARRAY(aux::byte);
+};
+template <class...>
+struct transition;
+template <class E, class G>
+struct transition<front::event<E>, G> {
+  template <class T>
+  auto operator/(const T &t) const {
+    return transition<front::event<E>, G, aux::zero_wrapper<T>>{e, g, aux::zero_wrapper<T>{t}};
+  }
+  front::event<E> e;
+  G g;
+};
+template <class E, class G, class A>
+struct transition<front::event<E>, G, A> {
+  front::event<E> e;
+  G g;
+  A a;
+};
+template <class S2, class G, class A>
+struct transition<state<S2>, G, A> : transition<state<internal>, state<S2>, front::event<back::anonymous>, G, A> {
+  using transition<state<internal>, state<S2>, front::event<back::anonymous>, G, A>::g;
+  using transition<state<internal>, state<S2>, front::event<back::anonymous>, G, A>::a;
+  transition(const G &g, const A &a) : transition<state<internal>, state<S2>, front::event<back::anonymous>, G, A>{g, a} {}
+  template <class T>
+  auto operator=(const T &) const {
+    return transition<T, state<S2>, front::event<back::anonymous>, G, A>{g, a};
+  }
+};
+template <class S1, class S2>
+struct transition<state<S1>, state<S2>> : transition<state<S1>, state<S2>, front::event<back::anonymous>, always, none> {
+  transition(const state<S1> &, const state<S2> &)
+      : transition<state<S1>, state<S2>, front::event<back::anonymous>, always, none>{always{}, none{}} {}
+};
+template <class S2, class G>
+struct transition_sg<state<S2>, G> : transition<state<internal>, state<S2>, front::event<back::anonymous>, G, none> {
+  using transition<state<internal>, state<S2>, front::event<back::anonymous>, G, none>::g;
+  transition_sg(const state<S2> &, const G &g)
+      : transition<state<internal>, state<S2>, front::event<back::anonymous>, G, none>{g, none{}} {}
+  template <class T>
+  auto operator/(const T &t) const {
+    return transition<state<S2>, G, aux::zero_wrapper<T>>{g, aux::zero_wrapper<T>{t}};
+  }
+  template <class T>
+  auto operator=(const T &) const {
+    return transition<T, state<S2>, front::event<back::anonymous>, G, none>{g, none{}};
+  }
+};
+template <class S2, class A>
+struct transition_sa<state<S2>, A> : transition<state<internal>, state<S2>, front::event<back::anonymous>, always, A> {
+  using transition<state<internal>, state<S2>, front::event<back::anonymous>, always, A>::a;
+  transition_sa(const state<S2> &, const A &a)
+      : transition<state<internal>, state<S2>, front::event<back::anonymous>, always, A>{always{}, a} {}
+  template <class T>
+  auto operator=(const T &) const {
+    return transition<T, state<S2>, front::event<back::anonymous>, always, A>{always{}, a};
+  }
+};
+template <class S2, class E>
+struct transition<state<S2>, front::event<E>> {
+  template <class T>
+  auto operator=(const T &) const {
+    return transition<T, state<S2>, front::event<E>, always, none>{always{}, none{}};
+  }
+  const state<S2> &s2;
+  front::event<E> e;
+};
+template <class E, class G>
+struct transition_eg<front::event<E>, G> {
+  template <class T>
+  auto operator/(const T &t) const {
+    return transition<front::event<E>, G, aux::zero_wrapper<T>>{e, g, aux::zero_wrapper<T>{t}};
+  }
+  front::event<E> e;
+  G g;
+};
+template <class E, class A>
+struct transition_ea<front::event<E>, A> {
+  front::event<E> e;
+  A a;
+};
+template <class S1, class S2, class G, class A>
+struct transition<state<S1>, transition<state<S2>, G, A>>
+    : transition<state<S1>, state<S2>, front::event<back::anonymous>, G, A> {
+  transition(const state<S1> &, const transition<state<S2>, G, A> &t)
+      : transition<state<S1>, state<S2>, front::event<back::anonymous>, G, A>{t.g, t.a} {}
+};
+template <class S1, class E, class G, class A>
+struct transition<state<S1>, transition<front::event<E>, G, A>>
+    : transition<state<internal>, state<S1>, front::event<E>, G, A> {
+  using transition<state<internal>, state<S1>, front::event<E>, G, A>::g;
+  using transition<state<internal>, state<S1>, front::event<E>, G, A>::a;
+  transition(const state<S1> &, const transition<front::event<E>, G, A> &t)
+      : transition<state<internal>, state<S1>, front::event<E>, G, A>{t.g, t.a} {}
+  template <class T>
+  auto operator=(const T &) const {
+    return transition<T, state<S1>, front::event<E>, G, A>{g, a};
+  }
+};
+template <class S1, class S2, class E>
+struct transition<state<S1>, transition<state<S2>, front::event<E>>>
+    : transition<state<S1>, state<S2>, front::event<E>, always, none> {
+  transition(const state<S1> &, const transition<state<S2>, front::event<E>> &)
+      : transition<state<S1>, state<S2>, front::event<E>, always, none>{always{}, none{}} {}
+};
+template <class S1, class S2, class G>
+struct transition<state<S1>, transition_sg<state<S2>, G>>
+    : transition<state<S1>, state<S2>, front::event<back::anonymous>, G, none> {
+  transition(const state<S1> &, const transition_sg<state<S2>, G> &t)
+      : transition<state<S1>, state<S2>, front::event<back::anonymous>, G, none>{t.g, none{}} {}
+};
+template <class S1, class S2, class A>
+struct transition<state<S1>, transition_sa<state<S2>, A>>
+    : transition<state<S1>, state<S2>, front::event<back::anonymous>, always, A> {
+  transition(const state<S1> &, const transition_sa<state<S2>, A> &t)
+      : transition<state<S1>, state<S2>, front::event<back::anonymous>, always, A>{always{}, t.a} {}
+};
+template <class S2, class E, class G>
+struct transition<state<S2>, transition_eg<front::event<E>, G>>
+    : transition<state<internal>, state<S2>, front::event<E>, G, none> {
+  using transition<state<internal>, state<S2>, front::event<E>, G, none>::g;
+  transition(const state<S2> &, const transition_eg<front::event<E>, G> &t)
+      : transition<state<internal>, state<S2>, front::event<E>, G, none>{t.g, none{}} {}
+  template <class T>
+  auto operator=(const T &) const {
+    return transition<T, state<S2>, front::event<E>, G, none>{g, none{}};
+  }
+};
+template <class S1, class S2, class E, class G>
+struct transition<state<S1>, transition<state<S2>, transition_eg<front::event<E>, G>>>
+    : transition<state<S1>, state<S2>, front::event<E>, G, none> {
+  transition(const state<S1> &, const transition<state<S2>, transition_eg<front::event<E>, G>> &t)
+      : transition<state<S1>, state<S2>, front::event<E>, G, none>{t.g, none{}} {}
+};
+template <class S2, class E, class A>
+struct transition<state<S2>, transition_ea<front::event<E>, A>>
+    : transition<state<internal>, state<S2>, front::event<E>, always, A> {
+  using transition<state<internal>, state<S2>, front::event<E>, always, A>::a;
+  transition(const state<S2> &, const transition_ea<front::event<E>, A> &t)
+      : transition<state<internal>, state<S2>, front::event<E>, always, A>{always{}, t.a} {}
+  template <class T>
+  auto operator=(const T &) const {
+    return transition<T, state<S2>, front::event<E>, always, A>{always{}, a};
+  }
+};
+template <class S1, class S2, class E, class A>
+struct transition<state<S1>, transition<state<S2>, transition_ea<front::event<E>, A>>>
+    : transition<state<S1>, state<S2>, front::event<E>, always, A> {
+  transition(const state<S1> &, const transition<state<S2>, transition_ea<front::event<E>, A>> &t)
+      : transition<state<S1>, state<S2>, front::event<E>, always, A>{always{}, t.a} {}
+};
+template <class S1, class S2, class E, class G, class A>
+struct transition<state<S1>, transition<state<S2>, transition<front::event<E>, G, A>>>
+    : transition<state<S1>, state<S2>, front::event<E>, G, A> {
+  transition(const state<S1> &, const transition<state<S2>, transition<front::event<E>, G, A>> &t)
+      : transition<state<S1>, state<S2>, front::event<E>, G, A>{t.g, t.a} {}
+};
+template <class T, class TSubs, class... Ts, class... THs>
+void update_composite_states(TSubs &subs, aux::true_type, const aux::type_list<THs...> &) {
+  using state_t = typename T::state_t;
+  auto &sm = back::sub_sm<T>::get(&subs);
+  (void)sm;
+#if defined(__cpp_fold_expressions)
+  ((sm.current_state_[aux::get_id<state_t, THs>((typename T::initial_states_ids_t *)0)] =
+        aux::get_id<state_t, THs>((typename T::states_ids_t *)0)),
+   ...);
+#else
+  (void)aux::swallow{0, (sm.current_state_[aux::get_id<state_t, THs>((typename T::initial_states_ids_t *)0)] =
+                             aux::get_id<state_t, THs>((typename T::states_ids_t *)0),
+                         0)...};
+#endif
+}
+template <class T, class TSubs, class... Ts>
+void update_composite_states(TSubs &subs, aux::false_type, Ts &&...) {
+  back::sub_sm<T>::get(&subs).initialize(typename T::initial_states_t{});
+}
+template <class SM, class TDeps, class TSubs, class TSrcState, class TDstState>
+void update_current_state(SM &, TDeps &deps, TSubs &, typename SM::state_t &current_state,
+                          const typename SM::state_t &new_state, const TSrcState &, const TDstState &) {
+  back::policies::log_state_change<typename SM::sm_t>(aux::type<typename SM::logger_t>{}, deps,
+                                                      aux::string<typename TSrcState::type>{},
+                                                      aux::string<typename TDstState::type>{});
+  current_state = new_state;
+}
+template <class SM, class TDeps, class TSubs, class TSrcState, class T>
+void update_current_state(SM &, TDeps &deps, TSubs &subs, typename SM::state_t &current_state,
+                          const typename SM::state_t &new_state, const TSrcState &, const state<back::sm<T>> &) {
+  back::policies::log_state_change<typename SM::sm_t>(aux::type<typename SM::logger_t>{}, deps,
+                                                      aux::string<typename TSrcState::type>{}, aux::string<T>{});
+  current_state = new_state;
+  update_composite_states<back::sm_impl<T>>(subs, typename back::sm_impl<T>::has_history_states{},
+                                            typename back::sm_impl<T>::history_states_t{});
+}
+template <class S1, class S2, class E, class G, class A>
+struct transition<state<S1>, state<S2>, front::event<E>, G, A> {
+  static constexpr auto initial = state<S2>::initial;
+  static constexpr auto history = state<S2>::history;
+  using src_state = typename state<S2>::type;
+  using dst_state = typename state<S1>::type;
+  using event = E;
+  using guard = G;
+  using action = A;
+  using deps = aux::apply_t<aux::unique_t, aux::join_t<get_deps_t<G, E>, get_deps_t<A, E>>>;
+  transition(const G &g, const A &a) : g(g), a(a) {}
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state, aux::true_type) {
+    if (call<TEvent, args_t<G, TEvent>, typename SM::logger_t>::execute(g, event, sm, deps, subs)) {
+      sm.process_internal_event(back::on_exit<back::_, TEvent>{event}, deps, subs, current_state);
+      update_current_state(sm, deps, subs, current_state,
+                           aux::get_id<typename SM::state_t, dst_state>((typename SM::states_ids_t *)0), state<src_state>{},
+                           state<dst_state>{});
+      call<TEvent, args_t<A, TEvent>, typename SM::logger_t>::execute(a, event, sm, deps, subs);
+      sm.process_internal_event(back::on_entry<back::_, TEvent>{event}, deps, subs, current_state);
+      return true;
+    }
+    return false;
+  }
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state, aux::false_type) {
+    if (call<TEvent, args_t<G, TEvent>, typename SM::logger_t>::execute(g, event, sm, deps, subs)) {
+      update_current_state(sm, deps, subs, current_state,
+                           aux::get_id<typename SM::state_t, dst_state>((typename SM::states_ids_t *)0), state<src_state>{},
+                           state<dst_state>{});
+      call<TEvent, args_t<A, TEvent>, typename SM::logger_t>::execute(a, event, sm, deps, subs);
+      return true;
+    }
+    return false;
+  }
+  G g;
+  A a;
+};
+template <class S2, class E, class G, class A>
+struct transition<state<internal>, state<S2>, front::event<E>, G, A> {
+  static constexpr auto initial = state<S2>::initial;
+  static constexpr auto history = state<S2>::history;
+  using src_state = typename state<S2>::type;
+  using dst_state = internal;
+  using event = E;
+  using guard = G;
+  using action = A;
+  using deps = aux::apply_t<aux::unique_t, aux::join_t<get_deps_t<G, E>, get_deps_t<A, E>>>;
+  transition(const G &g, const A &a) : g(g), a(a) {}
+  template <class TEvent, class SM, class TDeps, class TSubs, class... Ts>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &, Ts &&...) {
+    if (call<TEvent, args_t<G, TEvent>, typename SM::logger_t>::execute(g, event, sm, deps, subs)) {
+      call<TEvent, args_t<A, TEvent>, typename SM::logger_t>::execute(a, event, sm, deps, subs);
+      return true;
+    }
+    return false;
+  }
+  G g;
+  A a;
+};
+template <class S1, class S2, class E, class A>
+struct transition<state<S1>, state<S2>, front::event<E>, always, A> {
+  static constexpr auto initial = state<S2>::initial;
+  static constexpr auto history = state<S2>::history;
+  using src_state = typename state<S2>::type;
+  using dst_state = typename state<S1>::type;
+  using event = E;
+  using guard = always;
+  using action = A;
+  using deps = aux::apply_t<aux::unique_t, get_deps_t<A, E>>;
+  transition(const always &, const A &a) : a(a) {}
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state, aux::true_type) {
+    sm.process_internal_event(back::on_exit<back::_, TEvent>{event}, deps, subs, current_state);
+    update_current_state(sm, deps, subs, current_state,
+                         aux::get_id<typename SM::state_t, dst_state>((typename SM::states_ids_t *)0), state<src_state>{},
+                         state<dst_state>{});
+    call<TEvent, args_t<A, TEvent>, typename SM::logger_t>::execute(a, event, sm, deps, subs);
+    sm.process_internal_event(back::on_entry<back::_, TEvent>{event}, deps, subs, current_state);
+    return true;
+  }
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state, aux::false_type) {
+    update_current_state(sm, deps, subs, current_state,
+                         aux::get_id<typename SM::state_t, dst_state>((typename SM::states_ids_t *)0), state<src_state>{},
+                         state<dst_state>{});
+    call<TEvent, args_t<A, TEvent>, typename SM::logger_t>::execute(a, event, sm, deps, subs);
+    return true;
+  }
+  A a;
+};
+template <class S2, class E, class A>
+struct transition<state<internal>, state<S2>, front::event<E>, always, A> {
+  static constexpr auto initial = state<S2>::initial;
+  static constexpr auto history = state<S2>::history;
+  using src_state = typename state<S2>::type;
+  using dst_state = internal;
+  using event = E;
+  using guard = always;
+  using action = A;
+  using deps = aux::apply_t<aux::unique_t, get_deps_t<A, E>>;
+  transition(const always &, const A &a) : a(a) {}
+  template <class TEvent, class SM, class TDeps, class TSubs, class... Ts>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &, Ts &&...) {
+    call<TEvent, args_t<A, TEvent>, typename SM::logger_t>::execute(a, event, sm, deps, subs);
+    return true;
+  }
+  A a;
+};
+template <class S1, class S2, class E, class G>
+struct transition<state<S1>, state<S2>, front::event<E>, G, none> {
+  static constexpr auto initial = state<S2>::initial;
+  static constexpr auto history = state<S2>::history;
+  using src_state = typename state<S2>::type;
+  using dst_state = typename state<S1>::type;
+  using event = E;
+  using guard = G;
+  using action = none;
+  using deps = aux::apply_t<aux::unique_t, get_deps_t<G, E>>;
+  transition(const G &g, const none &) : g(g) {}
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state, aux::true_type) {
+    if (call<TEvent, args_t<G, TEvent>, typename SM::logger_t>::execute(g, event, sm, deps, subs)) {
+      sm.process_internal_event(back::on_exit<back::_, TEvent>{event}, deps, subs, current_state);
+      update_current_state(sm, deps, subs, current_state,
+                           aux::get_id<typename SM::state_t, dst_state>((typename SM::states_ids_t *)0), state<src_state>{},
+                           state<dst_state>{});
+      sm.process_internal_event(back::on_entry<back::_, TEvent>{event}, deps, subs, current_state);
+      return true;
+    }
+    return false;
+  }
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state, aux::false_type) {
+    if (call<TEvent, args_t<G, TEvent>, typename SM::logger_t>::execute(g, event, sm, deps, subs)) {
+      update_current_state(sm, deps, subs, current_state,
+                           aux::get_id<typename SM::state_t, dst_state>((typename SM::states_ids_t *)0), state<src_state>{},
+                           state<dst_state>{});
+      return true;
+    }
+    return false;
+  }
+  G g;
+};
+template <class S2, class E, class G>
+struct transition<state<internal>, state<S2>, front::event<E>, G, none> {
+  static constexpr auto initial = state<S2>::initial;
+  static constexpr auto history = state<S2>::history;
+  using src_state = typename state<S2>::type;
+  using dst_state = internal;
+  using event = E;
+  using guard = G;
+  using action = none;
+  using deps = aux::apply_t<aux::unique_t, get_deps_t<G, E>>;
+  transition(const G &g, const none &) : g(g) {}
+  template <class TEvent, class SM, class TDeps, class TSubs, class... Ts>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &, Ts &&...) {
+    return call<TEvent, args_t<G, TEvent>, typename SM::logger_t>::execute(g, event, sm, deps, subs);
+  }
+  G g;
+};
+template <class S1, class S2, class E>
+struct transition<state<S1>, state<S2>, front::event<E>, always, none> {
+  static constexpr auto initial = state<S2>::initial;
+  static constexpr auto history = state<S2>::history;
+  using src_state = typename state<S2>::type;
+  using dst_state = typename state<S1>::type;
+  using event = E;
+  using guard = always;
+  using action = none;
+  using deps = aux::type_list<>;
+  transition(const always &, const none &) {}
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  bool execute(const TEvent &event, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state, aux::true_type) {
+    sm.process_internal_event(back::on_exit<back::_, TEvent>{event}, deps, subs, current_state);
+    update_current_state(sm, deps, subs, current_state,
+                         aux::get_id<typename SM::state_t, dst_state>((typename SM::states_ids_t *)0), state<src_state>{},
+                         state<dst_state>{});
+    sm.process_internal_event(back::on_entry<back::_, TEvent>{event}, deps, subs, current_state);
+    return true;
+  }
+  template <class TEvent, class SM, class TDeps, class TSubs>
+  bool execute(const TEvent &, SM &sm, TDeps &deps, TSubs &subs, typename SM::state_t &current_state, aux::false_type) {
+    update_current_state(sm, deps, subs, current_state,
+                         aux::get_id<typename SM::state_t, dst_state>((typename SM::states_ids_t *)0), state<src_state>{},
+                         state<dst_state>{});
+    return true;
+  }
+  __BOOST_SML_ZERO_SIZE_ARRAY(aux::byte);
+};
+template <class S2, class E>
+struct transition<state<internal>, state<S2>, front::event<E>, always, none> {
+  static constexpr auto initial = state<S2>::initial;
+  static constexpr auto history = state<S2>::history;
+  using src_state = typename state<S2>::type;
+  using dst_state = internal;
+  using event = E;
+  using guard = always;
+  using action = none;
+  using deps = aux::type_list<>;
+  transition(const always &, const none &) {}
+  template <class TEvent, class SM, class TDeps, class TSubs, class... Ts>
+  bool execute(const TEvent &, SM &, TDeps &, TSubs &, typename SM::state_t &, Ts &&...) {
+    return true;
+  }
+  __BOOST_SML_ZERO_SIZE_ARRAY(aux::byte);
+};
+}
+using _ = back::_;
+template <class TEvent>
+front::event<TEvent> event __BOOST_SML_VT_INIT;
+template <class TEvent>
+__BOOST_SML_UNUSED front::event<back::on_entry<_, TEvent>> on_entry __BOOST_SML_VT_INIT;
+template <class TEvent>
+__BOOST_SML_UNUSED front::event<back::on_exit<_, TEvent>> on_exit __BOOST_SML_VT_INIT;
+template <class TEvent>
+front::event<back::unexpected_event<TEvent>> unexpected_event __BOOST_SML_VT_INIT;
+template <class T>
+front::event<back::exception<T>> exception __BOOST_SML_VT_INIT;
+using anonymous = back::anonymous;
+using initial = back::initial;
+template <class T>
+typename front::state_sm<T>::type state __BOOST_SML_VT_INIT;
+#if !defined(_MSC_VER)
+template <class T, T... Chrs>
+auto operator""_s() {
+  return front::state<aux::string<T, Chrs...>>{};
+}
+template <class T, T... Chrs>
+auto operator""_e() {
+  return event<aux::string<T, Chrs...>>;
+}
+#endif
+__BOOST_SML_UNUSED static front::state<back::terminate_state> X;
+__BOOST_SML_UNUSED static front::history_state H;
+__BOOST_SML_UNUSED static front::actions::defer defer;
+__BOOST_SML_UNUSED static front::actions::process process;
+template <class... Ts, __BOOST_SML_REQUIRES(aux::is_same<aux::bool_list<aux::always<Ts>::value...>,
+                                                         aux::bool_list<concepts::transitional<Ts>::value...>>::value)>
+auto make_transition_table(Ts... ts) {
+  return aux::pool<Ts...>{ts...};
+}
+BOOST_SML_NAMESPACE_END
+#undef __BOOST_SML_UNUSED
+#undef __BOOST_SML_VT_INIT
+#undef __BOOST_SML_ZERO_SIZE_ARRAY
+#undef __BOOST_SML_ZERO_SIZE_ARRAY_CREATE
+#undef __BOOST_SML_TEMPLATE_KEYWORD
+#if defined(__clang__)
+#pragma clang diagnostic pop
+#elif defined(__GNUC__)
+#undef __has_builtin
+#pragma GCC diagnostic pop
+#elif defined(_MSC_VER)
+#undef __has_builtin
+#undef __has_builtin__make_integer_seq
+#endif
+#endif
+#endif
diff --git a/settings.ini b/settings.ini
new file mode 100755
index 0000000..a15c823
--- /dev/null
+++ b/settings.ini
@@ -0,0 +1,82 @@
+; sample settings file
+; commented settings are optional
+
+[logging]
+;core=2                 ; 0-trace  2-info  4-err   6-off
+                        ; 1-debug  3-warn  5-crit
+
+;tgvoip=5               ; same as core
+;pjsip=2                ; same as core
+;sip_messages=true      ; log sip messages if pjsip debug is enabled
+
+;console_min_level=0    ; minimal log level that will be written into console
+;file_min_level=0       ; same but into file
+
+;tdlib=3                ; TDLib is written to file only and has its own log level values
+                        ; not affected by other log settings
+                        ; 0-fatal   2-warnings  4-debug
+                        ; 1-errors  3-info      5-verbose debug
+
+[sip]
+;public_address=        ; Address to advertise as the address UDP transport.
+
+;stun_server=
+
+;port=5060
+;port_range=0           ; Specify the port range for socket binding, relative to the start
+                        ; port number specified in port.
+
+;id_uri=sip:localhost   ; The Address of Record or AOR, that is full SIP URL that identifies the account.
+                        ; The value can take name address or URL format, and will look something
+                        ; like "sip:account@serviceprovider".
+
+;callback_uri=          ; SIP URI for TG->SIP incoming calls processing
+
+;raw_pcm=true           ; use L16@48k codec if true or OPUS@48k otherwise
+                        ; keep true for lower CPU consumption
+
+;thread_count=1         ; Specify the number of worker threads to handle incoming RTP
+                        ; packets. A value of one is recommended for most applications.
+
+[telegram]
+api_id=                         ; Application identifier for Telegram API access
+api_hash=                       ; Application identifier hash for Telegram API access
+                                ; which can be obtained at https://my.telegram.org.
+
+;system_language_code=en-US     ; IETF language tag of the user's operating system language
+
+;device_model=PC                ; Model of the device the application is being run on
+
+;system_version=Linux           ; Version of the operating system the application is being run on
+
+;application_version=1.0
+
+;database_folder=               ; The path to the directory for the persistent TDLib database;
+                                ; if empty, the current working directory will be used.
+
+;udp_p2p=false                  ; True, if UDP peer-to-peer connections are supported
+
+;udp_reflector=true             ; True, if connection through UDP reflectors is supported.
+
+;enable_aec=false               ; acoustic echo cancellation
+;enable_ns=false                ; noise suppression
+;enable_agc=false               ; automatic gain control
+
+;use_proxy=false                ; use SOCKS5 proxy for MTProto requests
+;proxy_address=
+;proxy_port=0
+;proxy_username=
+;proxy_password=
+
+;use_voip_proxy=false           ; use SOCKS5 proxy for VoIP
+;voip_proxy_address=
+;voip_proxy_port=0
+;voip_proxy_username=
+;voip_proxy_password=
+
+[other]
+;extra_wait_time=30             ; If gateway gets temporary blocked with "Too Many Requests" reason,
+                                ; then block all outgoing telegram requests for X more seconds than was
+                                ; requested by server
+
+;peer_flood_time=86400          ; Seconds to wait on PEER_FLOOD
diff --git a/tg2sip/gateway.cpp b/tg2sip/gateway.cpp
new file mode 100755
index 0000000..52d2c99
--- /dev/null
+++ b/tg2sip/gateway.cpp
@@ -0,0 +1,883 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <regex>
+#include "gateway.h"
+
+namespace sml = boost::sml;
+namespace td_api = td::td_api;
+
+#define CALL_PROTO_MIN_LAYER 65
+#define CALL_PROTO_MAX_LAYER 74
+
+namespace state_machine::guards {
+    bool IsIncoming::operator()(const td::td_api::object_ptr<td::td_api::updateCall> &event) const {
+        return !event->call_->is_outgoing_;
+    }
+
+    bool IsInState::operator()(const td::td_api::object_ptr<td::td_api::updateCall> &event) const {
+        return event->call_->state_->get_id() == id_;
+    }
+
+    bool CallbackUriIsSet::operator()(const Settings &settings) const {
+        return !settings.callback_uri().empty();
+    }
+
+    bool IsMediaReady::operator()(const sip::events::CallMediaStateUpdate &event) const {
+        return event.has_media;
+    }
+
+    bool IsSipInState::operator()(const sip::events::CallStateUpdate &event) const {
+        return event.state == state_;
+    }
+
+    bool IsTextContent::operator()(const td::td_api::object_ptr<td::td_api::updateNewMessage> &event) const {
+        return event->message_->content_->get_id() == td::td_api::messageText::ID;
+    }
+
+    bool IsDtmfString::operator()(const td::td_api::object_ptr<td::td_api::updateNewMessage> &event) const {
+
+        // String must contain only characters as described on RFC 2833 section 3.10.
+        // if PJMEDIA_HAS_DTMF_FLASH is enabled, character 'R' is used to represent
+        // the event type 16 (flash) as stated in RFC 4730.
+        // PJSUA maximum number of characters are 32.
+
+        auto content = td_api::move_object_as<td_api::messageText>(event->message_->content_);
+        const std::regex dtmf_regex("^[0-9A-D*#]{1,32}$");
+        auto result = regex_match(content->text_->text_, dtmf_regex);
+
+        // Don't forget to put data back!
+        event->message_->content_ = td_api::move_object_as<td_api::MessageContent>(content);
+
+        return result;
+    }
+}
+
+namespace state_machine::actions {
+    void StoreSipId::operator()(Context &ctx, const sip::events::IncomingCall &event,
+                                std::shared_ptr<spdlog::logger> logger) const {
+        ctx.sip_call_id = event.id;
+        DEBUG(logger, "[{}] associated with SIP#{}", ctx.id(), ctx.sip_call_id);
+    }
+
+    void StoreTgId::operator()(Context &ctx, const td::td_api::object_ptr<td::td_api::updateCall> &event,
+                               std::shared_ptr<spdlog::logger> logger) const {
+        ctx.tg_call_id = event->call_->id_;
+        DEBUG(logger, "[{}] associated with TG#{}", ctx.id(), ctx.tg_call_id);
+    }
+
+    void StoreTgUserId::operator()(Context &ctx, const td::td_api::object_ptr<td::td_api::updateCall> &event,
+                                   std::shared_ptr<spdlog::logger> logger) const {
+        ctx.user_id = event->call_->user_id_;
+        DEBUG(logger, "[{}] stored user id {}", ctx.id(), ctx.user_id);
+    }
+
+    void CleanTgId::operator()(Context &ctx) const {
+        ctx.tg_call_id = 0;
+    }
+
+    void CleanSipId::operator()(Context &ctx) const {
+        ctx.sip_call_id = PJSUA_INVALID_ID;
+    }
+
+
+    void CleanUp::operator()(Context &ctx, sip::Client &sip_client, tg::Client &tg_client,
+                             std::shared_ptr<spdlog::logger> logger) const {
+        TRACE(logger, "[{}] cleanup start", ctx.id());
+
+        if (ctx.controller) {
+            ctx.controller->Stop();
+        }
+
+        if (ctx.tg_call_id != 0) {
+            DEBUG(logger, "[{}] hangup TG #{}", ctx.id(), ctx.tg_call_id);
+
+            auto result = tg_client.send_query_async(td_api::make_object<td_api::discardCall>(
+                    ctx.tg_call_id, /* call_id_ */
+                    false, /* is_disconnected_ */
+                    0, /* duration_ */
+                    ctx.tg_call_id /*connection_id */
+            )).get();
+
+            if (result->get_id() == td_api::error::ID) {
+                logger->error("[{}] TG call discard failure:\n{}", ctx.id(), to_string(result));
+            }
+
+            ctx.tg_call_id = 0;
+        }
+
+        if (ctx.sip_call_id != PJSUA_INVALID_ID) {
+            try {
+                sip_client.Hangup(ctx.sip_call_id, ctx.hangup_prm);
+            } catch (const pj::Error &error) {
+                logger->error(error.reason);
+            }
+            ctx.sip_call_id = PJSUA_INVALID_ID;
+        }
+
+        TRACE(logger, "[{}] cleanup end");
+    }
+
+    void DialSip::operator()(Context &ctx, tg::Client &tg_client, sip::Client &sip_client,
+                             const td_api::object_ptr<td_api::updateCall> &event,
+                             OptionalQueue<state_machine::events::Event> &internal_events,
+                             const Settings &settings, std::shared_ptr<spdlog::logger> logger) const {
+
+        auto tg_user_id = event->call_->user_id_;
+        auto response = tg_client.send_query_async(td_api::make_object<td_api::getUser>(tg_user_id)).get();
+
+        if (response->get_id() == td_api::error::ID) {
+            logger->error("[{}] get user info of id {} failed\n{}", ctx.id(), tg_user_id, to_string(response));
+            auto err = td_api::move_object_as<td_api::error>(response);
+            throw std::runtime_error{err->message_};
+        }
+
+        auto user = td::move_tl_object_as<td_api::user>(response);
+        auto prm = pj::CallOpParam(true);
+
+        auto &headers = prm.txOption.headers;
+        auto header = pj::SipHeader();
+
+        {
+            // debug purpose header
+            header.hName = "X-GW-Context";
+            header.hValue = ctx.id();
+            headers.push_back(header);
+        }
+
+        {
+            header.hName = "X-TG-ID";
+            header.hValue = std::to_string(tg_user_id);
+            headers.push_back(header);
+        }
+
+        if (!user->first_name_.empty()) {
+            header.hName = "X-TG-FirstName";
+            header.hValue = user->first_name_;
+            headers.push_back(header);
+        }
+
+        if (!user->last_name_.empty()) {
+            header.hName = "X-TG-LastName";
+            header.hValue = user->last_name_;
+            headers.push_back(header);
+        }
+
+        if (!user->username_.empty()) {
+            header.hName = "X-TG-Username";
+            header.hValue = user->username_;
+            headers.push_back(header);
+        }
+
+        if (!user->phone_number_.empty()) {
+            header.hName = "X-TG-Phone";
+            header.hValue = user->phone_number_;
+            headers.push_back(header);
+        }
+
+        try {
+            ctx.sip_call_id = sip_client.Dial(settings.callback_uri(), prm);
+        } catch (const pj::Error &error) {
+            pj::CallOpParam hangup_prm;
+            hangup_prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            hangup_prm.reason = error.reason;
+
+            internal_events.emplace(state_machine::events::InternalError{ctx.id(), hangup_prm});
+
+            return;
+        }
+
+        DEBUG(logger, "[{}] associated with SIP#{}", ctx.id(), ctx.sip_call_id);
+    }
+
+    void AnswerTg::operator()(Context &ctx, tg::Client &tg_client, const Settings &settings,
+                              OptionalQueue<state_machine::events::Event> &internal_events,
+                              std::shared_ptr<spdlog::logger> logger) const {
+
+        auto response = tg_client.send_query_async(td_api::make_object<td_api::acceptCall>(
+                ctx.tg_call_id,
+                td_api::make_object<td_api::callProtocol>(settings.udp_p2p(),
+                                                          settings.udp_reflector(),
+                                                          CALL_PROTO_MIN_LAYER, CALL_PROTO_MAX_LAYER)
+        )).get();
+
+        if (response->get_id() == td_api::error::ID) {
+            logger->error("[{}] TG #{} accept failure\n{}", ctx.id(), ctx.tg_call_id, to_string(response));
+
+            auto error = td::move_tl_object_as<td_api::error>(response);
+
+            pj::CallOpParam hangup_prm;
+            hangup_prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            hangup_prm.reason = std::to_string(error->code_) + "; " + error->message_;
+
+            internal_events.emplace(state_machine::events::InternalError{ctx.id(), hangup_prm});
+        }
+
+    }
+
+    void AcceptIncomingSip::operator()(Context &ctx, sip::Client &sip_client, const Settings &settings,
+                                       const sip::events::IncomingCall &event,
+                                       OptionalQueue<state_machine::events::Event> &internal_events,
+                                       std::shared_ptr<spdlog::logger> logger) const {
+        auto ext = event.extension;
+
+        bool ext_valid{true};
+
+        if (ext.length() > 3 && ext.substr(0, 3) == "tg#") {
+            ctx.ext_username = ext.substr(3, std::string::npos);
+        } else if (ext.length() > 1 && ext[0] == '+' && is_digits(ext.substr(1, std::string::npos))) {
+            ctx.ext_phone = ext.substr(1, std::string::npos);
+        } else if (is_digits(ext)) {
+            try {
+                ctx.user_id = std::stoi(ext);
+            } catch (const std::invalid_argument &e) {
+                ext_valid = false;
+            } catch (const std::out_of_range &e) {
+                ext_valid = false;
+            }
+        } else {
+            ext_valid = false;
+        }
+
+        if (ext_valid) {
+            auto a_prm = pj::CallOpParam(true);
+            a_prm.statusCode = PJSIP_SC_RINGING;
+            DEBUG(logger, "[{}] setting SIP #{} in ringing mode", ctx.id(), ctx.sip_call_id);
+            try {
+                sip_client.Answer(ctx.sip_call_id, a_prm);
+            } catch (const pj::Error &error) {
+                pj::CallOpParam hangup_prm;
+                hangup_prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+                hangup_prm.reason = error.reason;
+                internal_events.emplace(state_machine::events::InternalError{ctx.id(), hangup_prm});
+            } catch (const std::runtime_error &error) {
+                pj::CallOpParam hangup_prm;
+                hangup_prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+                hangup_prm.reason = error.what();
+                internal_events.emplace(state_machine::events::InternalError{ctx.id(), hangup_prm});
+            }
+
+        } else {
+            pj::CallOpParam prm;
+            prm.statusCode = PJSIP_SC_BAD_EXTENSION;
+            logger->warn("[{}] called invalid extension {}", ctx.id(), ext);
+            internal_events.emplace(state_machine::events::InternalError{ctx.id(), prm});
+        }
+    }
+
+    void AnswerSip::operator()(Context &ctx, sip::Client &sip_client, const Settings &settings,
+                               OptionalQueue<state_machine::events::Event> &internal_events,
+                               std::shared_ptr<spdlog::logger> logger) const {
+
+        auto prm = pj::CallOpParam(true);
+        prm.statusCode = PJSIP_SC_OK;
+        DEBUG(logger, "[{}] answering SIP #{}", ctx.id(), ctx.sip_call_id);
+
+        try {
+            sip_client.Answer(ctx.sip_call_id, prm);
+        } catch (const pj::Error &error) {
+            pj::CallOpParam hangup_prm;
+            hangup_prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            hangup_prm.reason = error.reason;
+            internal_events.emplace(state_machine::events::InternalError{ctx.id(), hangup_prm});
+        } catch (const std::runtime_error &error) {
+            pj::CallOpParam hangup_prm;
+            hangup_prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            hangup_prm.reason = error.what();
+            internal_events.emplace(state_machine::events::InternalError{ctx.id(), hangup_prm});
+        }
+    }
+
+    void state_machine::actions::CreateTgVoip::operator()(Context &ctx, const Settings &settings,
+                                                          const td::td_api::object_ptr<td::td_api::updateCall> &event,
+                                                          std::shared_ptr<spdlog::logger> logger) const {
+
+        DEBUG(logger, "[{}] creating voip for TG #{}", ctx.id(), ctx.tg_call_id);
+
+        using namespace tgvoip;
+
+        auto state = td_api::move_object_as<td_api::callStateReady>(event->call_->state_);
+        auto voip_controller = std::make_shared<VoIPController>();
+
+        static auto config = VoIPController::Config(
+                3000,   /*init_timeout*/
+                3000,   /*recv_timeout*/
+                DATA_SAVING_NEVER, /*data_saving*/
+                settings.aec_enabled(),   /*enableAEC*/
+                settings.ns_enabled(),  /*enableNS*/
+                settings.agc_enabled(),  /*enableAGC*/
+                false   /*enableCallUpgrade*/
+        );
+        voip_controller->SetConfig(config);
+        if (settings.voip_proxy_enabled()) {
+            voip_controller->SetProxy(
+                    PROXY_SOCKS5,
+                    settings.voip_proxy_address(),
+                    settings.voip_proxy_port(),
+                    settings.voip_proxy_username(),
+                    settings.voip_proxy_password()
+            );
+        }
+
+        char encryption_key[256];
+        memcpy(encryption_key, state->encryption_key_.c_str(), 256);
+        voip_controller->SetEncryptionKey(encryption_key, event->call_->is_outgoing_);
+
+        vector<Endpoint> endpoints;
+        for (auto &connection : state->connections_) {
+            unsigned char peer_tag[16];
+            memcpy(peer_tag, connection->peer_tag_.c_str(), 16);
+            auto ipv4 = IPv4Address(connection->ip_);
+            auto ipv6 = IPv6Address(connection->ipv6_);
+            endpoints.emplace_back(Endpoint(connection->id_,
+                                            static_cast<uint16_t>(connection->port_),
+                                            ipv4,
+                                            ipv6,
+                                            Endpoint::TYPE_UDP_RELAY,
+                                            peer_tag));
+        }
+        voip_controller->SetRemoteEndpoints(endpoints, settings.udp_p2p(), CALL_PROTO_MAX_LAYER);
+        voip_controller->Start();
+        voip_controller->Connect();
+
+        ctx.controller = std::move(voip_controller);
+    }
+
+    void state_machine::actions::BridgeAudio::operator()(Context &ctx, sip::Client &sip_client,
+                                                         OptionalQueue<state_machine::events::Event> &internal_events,
+                                                         std::shared_ptr<spdlog::logger> logger) const {
+        DEBUG(logger, "[{}] bridging tgvoip audio with SIP#{}", ctx.id(), ctx.sip_call_id);
+
+        try {
+            sip_client.BridgeAudio(ctx.sip_call_id,
+                                   ctx.controller->AudioMediaInput(),
+                                   ctx.controller->AudioMediaOutput());
+        } catch (const pj::Error &error) {
+            pj::CallOpParam hangup_prm;
+            hangup_prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            hangup_prm.reason = error.reason;
+            internal_events.emplace(state_machine::events::InternalError{ctx.id(), hangup_prm});
+        } catch (const std::runtime_error &error) {
+            pj::CallOpParam hangup_prm;
+            hangup_prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            hangup_prm.reason = error.what();
+            internal_events.emplace(state_machine::events::InternalError{ctx.id(), hangup_prm});
+        }
+    }
+
+    void SetHangupPrm::operator()(Context &ctx, const state_machine::events::InternalError &event) const {
+        ctx.hangup_prm = event.prm;
+    }
+
+    void DialTg::operator()(Context &ctx, tg::Client &tg_client, const Settings &settings, Cache &cache,
+                            std::chrono::steady_clock::time_point &block_until,
+                            OptionalQueue<state_machine::events::Event> &internal_events,
+                            std::shared_ptr<spdlog::logger> logger) {
+
+        DEBUG(logger, "[{}] dialing tg", ctx.id());
+
+        ctx_ = &ctx;
+        tg_client_ = &tg_client;
+        settings_ = &settings;
+        cache_ = &cache;
+        block_until_ = &block_until;
+        internal_events_ = &internal_events;
+        logger_ = logger;
+
+        if (block_until > std::chrono::steady_clock::now()) {
+            auto seconds_left = std::chrono::duration_cast<std::chrono::seconds>(
+                    block_until - std::chrono::steady_clock::now()).count();
+
+            DEBUG(logger, "[{}] dropping call cause of temp TG block for {} seconds", ctx.id(), seconds_left);
+
+            pj::CallOpParam prm;
+            prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            prm.reason = "FLOOD_WAIT " + std::to_string(seconds_left);
+            internal_events.emplace(state_machine::events::InternalError{ctx.id(), prm});
+            return;
+        }
+
+        if (!ctx.ext_username.empty()) {
+            dial_by_username();
+        } else if (!ctx.ext_phone.empty()) {
+            dial_by_phone();
+        } else {
+            dial_by_id(ctx.user_id);
+        }
+    }
+
+    void DialTg::dial_by_id(int32_t id) {
+        auto response = tg_client_->send_query_async(td_api::make_object<td_api::createCall>(
+                id /* id */,
+                td_api::make_object<td_api::callProtocol>(settings_->udp_p2p(), settings_->udp_reflector(),
+                                                          CALL_PROTO_MIN_LAYER, CALL_PROTO_MAX_LAYER))
+        ).get();
+
+        if (response->get_id() == td_api::error::ID) {
+            logger_->error("[{}] failed to create telegram call\n{}", ctx_->id(), to_string(response));
+
+            auto error = td::move_tl_object_as<td_api::error>(response);
+
+            auto prm = pj::CallOpParam(true);
+            prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            prm.reason = std::to_string(error->code_) + "; " + error->message_;
+
+            internal_events_->emplace(state_machine::events::InternalError{ctx_->id(), prm});
+
+            parse_error(std::move(error));
+            return;
+        }
+
+        auto call_id_ = td::move_tl_object_as<td_api::callId>(response);
+
+        DEBUG(logger_, "[{}] associated with TG#{}", ctx_->id(), call_id_->id_);
+        ctx_->tg_call_id = call_id_->id_;
+    }
+
+    void DialTg::dial_by_phone() {
+
+        auto it = cache_->phone_cache.find(ctx_->ext_phone);
+        if (it != cache_->phone_cache.end()) {
+            DEBUG(logger_, "[{}] found id {} for {} in phone cache", ctx_->id(), it->second, ctx_->ext_phone);
+            dial_by_id(it->second);
+            return;
+        }
+
+        auto contact = td_api::make_object<td_api::contact>();
+        contact->phone_number_ = ctx_->ext_phone;
+
+        auto contacts = std::vector<td_api::object_ptr<td_api::contact>>();
+        contacts.emplace_back(std::move(contact));
+
+        auto response = tg_client_->send_query_async(
+                td_api::make_object<td_api::importContacts>(std::move(contacts))).get();
+
+        if (response->get_id() == td_api::error::ID) {
+            logger_->error("[{}] contacts import failure\n{}", ctx_->id(), to_string(response));
+            auto error = td::move_tl_object_as<td_api::error>(response);
+
+            auto prm = pj::CallOpParam(true);
+            prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            prm.reason = std::to_string(error->code_) + "; " + error->message_;
+            internal_events_->emplace(state_machine::events::InternalError{ctx_->id(), prm});
+
+            parse_error(std::move(error));
+            return;
+        }
+
+        auto imported_contacts = td::move_tl_object_as<td_api::importedContacts>(response);
+        auto user_id_ = imported_contacts->user_ids_[0];
+
+        if (user_id_ == 0) {
+            logger_->error("[{}] {} is not telegram user yet", ctx_->id(), ctx_->ext_phone);
+
+            auto prm = pj::CallOpParam(true);
+            prm.statusCode = PJSIP_SC_NOT_FOUND;
+            prm.reason = "not registered in telegram";
+            internal_events_->emplace(state_machine::events::InternalError{ctx_->id(), prm});
+
+            return;
+        }
+
+        DEBUG(logger_, "[{}] adding id {} for {} to phone cache", ctx_->id(), user_id_, ctx_->ext_phone);
+        cache_->phone_cache.emplace(ctx_->ext_phone, user_id_);
+        dial_by_id(user_id_);
+    }
+
+    void DialTg::dial_by_username() {
+        auto it = cache_->username_cache.find(ctx_->ext_username);
+        if (it != cache_->username_cache.end()) {
+            DEBUG(logger_, "[{}] found id {} for {} in username cache", ctx_->id(), it->second, ctx_->ext_username);
+            dial_by_id(it->second);
+            return;
+        }
+
+        auto response = tg_client_->send_query_async(
+                td_api::make_object<td_api::searchPublicChat>(ctx_->ext_username)).get();
+
+        if (response->get_id() == td_api::error::ID) {
+            logger_->error("[{}] chat request failure\n{}", ctx_->id(), to_string(response));
+
+            auto error = td::move_tl_object_as<td_api::error>(response);
+
+            auto prm = pj::CallOpParam(true);
+            prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            prm.reason = std::to_string(error->code_) + "; " + error->message_;
+            internal_events_->emplace(state_machine::events::InternalError{ctx_->id(), prm});
+
+            parse_error(std::move(error));
+            return;
+        }
+
+        auto chat = td::move_tl_object_as<td_api::chat>(response);
+
+        if (chat->type_->get_id() != td_api::chatTypePrivate::ID) {
+
+            auto prm = pj::CallOpParam(true);
+            prm.statusCode = PJSIP_SC_INTERNAL_SERVER_ERROR;
+            prm.reason = "not a user";
+            internal_events_->emplace(state_machine::events::InternalError{ctx_->id(), prm});
+
+            return;
+        }
+
+        auto id = static_cast<int32_t>(chat->id_);
+        DEBUG(logger_, "[{}] adding id {} for {} to username cache", ctx_->id(), id, ctx_->ext_username);
+        cache_->username_cache.emplace(ctx_->ext_username, id);
+        dial_by_id(id);
+    }
+
+    void DialTg::parse_error(td_api::object_ptr<td::td_api::error> error) {
+        std::smatch match;
+
+        const std::regex delay_regex("Too Many Requests: retry after (\\d+)");
+        if (std::regex_search(error->message_, match, delay_regex)) {
+            auto seconds = std::stoi(match[1]);
+            *block_until_ = std::chrono::steady_clock::now() +
+                            std::chrono::seconds(seconds + settings_->extra_wait_time());
+            return;
+        }
+
+        const std::regex flood_regex("PEER_FLOOD");
+        if (std::regex_search(error->message_, match, flood_regex)) {
+            *block_until_ = std::chrono::steady_clock::now() + std::chrono::seconds(settings_->peer_flood_time());
+            return;
+        }
+    }
+
+    void DialDtmf::operator()(Context &ctx, sip::Client &sip_client,
+                              const td_api::object_ptr<td::td_api::updateNewMessage> &event,
+                              std::shared_ptr<spdlog::logger> logger) const {
+
+        auto content = td_api::move_object_as<td_api::messageText>(event->message_->content_);
+        DEBUG(logger, "[{}] sending DTMF {}", ctx.id(), content->text_->text_);
+        try {
+            sip_client.DialDtmf(ctx.sip_call_id, content->text_->text_);
+        } catch (const pj::Error &error) {
+            logger->error(error.reason);
+        }
+    }
+}
+
+namespace state_machine {
+
+    Logger::Logger(std::string context_id, shared_ptr<spdlog::logger> logger) : logger_(std::move(logger)),
+                                                                                context_id_(std::move(context_id)) {
+        TRACE(logger_, "[{}] logger created", context_id_);
+    }
+
+    Logger::~Logger() {
+        TRACE(logger_, "[{}] ~logger", context_id_);
+    };
+
+    template<class SM>
+    void Logger::log_process_event(const td::td_api::object_ptr<td::td_api::updateCall> &event) {
+        TRACE(logger_, "[{}] [process_event]\n{}", context_id_, td::td_api::to_string(event));
+    };
+
+    template<class SM>
+    void Logger::log_process_event(const sip::events::Event &event) {
+        TRACE(logger_, "[{}] [process_event] sip", context_id_);
+    };
+
+    template<class SM, class TEvent>
+    void Logger::log_process_event(const TEvent &) {
+        TRACE(logger_, "[{}] [process_event] {}", context_id_, sml::aux::get_type_name<TEvent>());
+    }
+
+    template<class SM, class TGuard, class TEvent>
+    void Logger::log_guard(const TGuard &, const TEvent &event, bool result) {
+        TRACE(logger_, "[{}] [guard] {} {} {}", context_id_, sml::aux::get_type_name<TGuard>(),
+              "event", (result ? "[OK]" : "[Reject]"));
+    };
+
+    template<class SM, class TAction, class TEvent>
+    void Logger::log_action(const TAction &, const TEvent &event) {
+        TRACE(logger_, "[{}] [action] {} {}", context_id_, sml::aux::get_type_name<TAction>(), "event");
+    };
+
+    template<class SmLogger, class TSrcState, class TDstState>
+    void Logger::log_state_change(const TSrcState &src, const TDstState &dst) {
+        TRACE(logger_, "[{}] [transition] {} -> {}", context_id_, src.c_str(), dst.c_str());
+    }
+
+    struct from_tg {
+        auto operator()() const {
+            using namespace boost::sml;
+            using namespace td::td_api;
+            using namespace guards;
+            using namespace actions;
+            return make_transition_table(
+                    *"sip_wait_media"_s + event<sip::events::CallMediaStateUpdate>[IsMediaReady{}]
+                                          / AnswerTg{} = "wait_tg"_s,
+                    "wait_tg"_s + event<object_ptr<updateCall>>[IsInState{callStateReady::ID}]
+                                  / (CreateTgVoip{}, BridgeAudio{}) = "wait_dtmf"_s,
+                    "wait_dtmf"_s + event<object_ptr<updateNewMessage>>[IsTextContent{} && IsDtmfString{}]
+                                  / DialDtmf{} = "wait_dtmf"_s
+            );
+        }
+    };
+
+    struct from_sip {
+        auto operator()() const {
+            using namespace boost::sml;
+            using namespace td::td_api;
+            using namespace guards;
+            using namespace actions;
+            return make_transition_table(
+                    *"sip_wait_confirm"_s + event<sip::events::CallStateUpdate>
+                                            [IsSipInState{PJSIP_INV_STATE_EARLY}] / DialTg{} = "wait_tg"_s,
+                    "wait_tg"_s + event<object_ptr<updateCall>>[IsInState{callStateReady::ID}]
+                                  / (StoreTgUserId{}, CreateTgVoip{}, AnswerSip{}) = "sip_wait_media"_s,
+                    "sip_wait_media"_s + event<sip::events::CallMediaStateUpdate>[IsMediaReady{}]
+                                         / BridgeAudio{} = "wait_dtmf"_s,
+                    "wait_dtmf"_s + event<object_ptr<updateNewMessage>>[IsTextContent{} && IsDtmfString{}]
+                                    / DialDtmf{} = "wait_dtmf"_s
+            );
+        }
+    };
+
+    struct StateMachine {
+        auto operator()() const {
+            using namespace boost::sml;
+            using namespace td::td_api;
+            using namespace guards;
+            using namespace actions;
+            using namespace events;
+            return make_transition_table(
+                    *"init"_s + event<object_ptr<updateCall>>
+                                [IsIncoming{} && IsInState{callStatePending::ID} && CallbackUriIsSet{}]
+                                / (StoreTgId{}, StoreTgUserId{}, DialSip{}) = state<from_tg>,
+                    "init"_s + event<object_ptr<updateCall>>
+                               [IsIncoming{} && IsInState{callStatePending::ID} && !CallbackUriIsSet{}]
+                               / StoreTgId{} = X,
+                    "init"_s + event<object_ptr<updateCall>> = X,
+                    "init"_s + event<sip::events::IncomingCall> / (StoreSipId{}, AcceptIncomingSip{}) = state<from_sip>,
+                    "init"_s + event<sip::events::CallStateUpdate> = X,
+                    "init"_s + event<sip::events::CallMediaStateUpdate> = X,
+
+                    state<from_tg> + event<object_ptr<updateCall>>
+                                     [IsInState{callStateDiscarded::ID} || IsInState{callStateError::ID}] /
+                                     CleanTgId{} = X,
+                    state<from_tg> + event<sip::events::CallStateUpdate>
+                                     [IsSipInState{PJSIP_INV_STATE_DISCONNECTED}] / CleanSipId{} = X,
+                    state<from_tg> + event<InternalError> / SetHangupPrm{} = X,
+
+                    state<from_sip> + event<object_ptr<updateCall>>
+                                      [IsInState{callStateDiscarded::ID} || IsInState{callStateError::ID}] /
+                                      CleanTgId{} = X,
+                    state<from_sip> + event<InternalError> / SetHangupPrm{} = X,
+                    state<from_sip> + event<sip::events::CallStateUpdate>
+                                      [IsSipInState{PJSIP_INV_STATE_DISCONNECTED}] / CleanSipId{} = X,
+
+                    X + on_entry<_> / CleanUp{}
+            );
+        }
+    };
+}
+
+Context::Context() : id_(next_ctx_id()) {}
+
+const std::string Context::id() const { return id_; };
+
+std::string Context::next_ctx_id() {
+    static int64_t ctx_counter{0};
+    static std::string id_prefix = std::to_string(getpid()) + "-";
+    return id_prefix + std::to_string(++ctx_counter);
+}
+
+Gateway::Gateway(sip::Client &sip_client_, tg::Client &tg_client_,
+                 OptionalQueue<sip::events::Event> &sip_events_,
+                 OptionalQueue<tg::Client::Object> &tg_events_,
+                 std::shared_ptr<spdlog::logger> logger_,
+                 Settings &settings)
+        : sip_client_(sip_client_), tg_client_(tg_client_), logger_(std::move(logger_)),
+          sip_events_(sip_events_), tg_events_(tg_events_), settings_(settings) {}
+
+void Gateway::start(volatile sig_atomic_t e_flag) {
+
+    load_cache();
+
+    while (!e_flag) {
+        auto tick_start = std::chrono::steady_clock::now();
+
+        if (auto event = internal_events_.pop(); event) {
+            std::visit([this](auto &&casted_event) {
+                process_event(casted_event);
+            }, event.value());
+        }
+
+        if (auto event = tg_events_.pop(); event) {
+            using namespace td::td_api;
+            auto &&object = event.value();
+            switch (object->get_id()) {
+                case updateCall::ID:
+                    process_event(move_object_as<updateCall>(object));
+                    break;
+                case updateNewMessage::ID:
+                    process_event(move_object_as<updateNewMessage>(object));
+                    break;
+                default:
+                    break;
+            }
+        }
+
+        if (auto event = sip_events_.pop(); event) {
+            std::visit([this](auto &&casted_event) {
+                process_event(casted_event);
+            }, event.value());
+        }
+
+        auto tick_end = std::chrono::steady_clock::now();
+        auto duration = tick_end - tick_start;
+        auto sleep_time = std::chrono::milliseconds(10) - duration;
+        if (sleep_time.count() > 0) {
+            std::this_thread::sleep_for(sleep_time);
+        }
+    }
+
+}
+
+void Gateway::load_cache() {
+    logger_->info("Loading contacts cache");
+
+    auto search_response = tg_client_.send_query_async(
+            td::td_api::make_object<td::td_api::searchContacts>("", INT32_MAX)).get();
+    if (search_response->get_id() == td::td_api::error::ID) {
+        logger_->error("offline contacts search failed during cache fill\n{}", to_string(search_response));
+        return;
+    }
+
+    auto users = td::td_api::move_object_as<td::td_api::users>(search_response);
+    std::vector<std::future<tg::Client::Object>> responses;
+    for (auto user_id : users->user_ids_) {
+        responses.emplace_back(tg_client_.send_query_async(td::td_api::make_object<td::td_api::getUser>(user_id)));
+    }
+    for (auto &future : responses) {
+        auto response = future.get();
+
+        if (response->get_id() == td::td_api::error::ID) {
+            logger_->error("failed to get user info from DB\n{}", to_string(response));
+            continue;
+        }
+
+        auto user = td::td_api::move_object_as<td::td_api::user>(response);
+
+        if (!user->have_access_) {
+            return;
+        }
+
+        if (!user->username_.empty()) {
+            cache_.username_cache.emplace(user->username_, user->id_);
+        }
+
+        if (!user->phone_number_.empty()) {
+            cache_.phone_cache.emplace(user->phone_number_, user->id_);
+        }
+    }
+
+    logger_->info("Loaded {} usernames and {} phones into contacts cache",
+                  cache_.username_cache.size(),
+                  cache_.phone_cache.size());
+}
+
+std::vector<Bridge *>::iterator Gateway::search_call(const std::function<bool(const Bridge *)> &predicate) {
+    auto iter = std::find_if(bridges.begin(), bridges.end(), predicate);
+
+    if (iter == bridges.end()) {
+        auto ctx = std::make_unique<Context>();
+        auto sm_logger = std::make_unique<state_machine::Logger>(ctx->id(), logger_);
+        auto sm = std::make_unique<state_machine::sm_t>(*sm_logger, sip_client_, tg_client_, settings_, logger_,
+                                                        *ctx, cache_, internal_events_, block_until);
+
+        auto bridge = new Bridge;
+        bridge->ctx = std::move(ctx);
+        bridge->sm = std::move(sm);
+        bridge->logger = std::move(sm_logger);
+
+        bridges.emplace_back(bridge);
+        iter = bridges.end() - 1;
+    }
+
+    return iter;
+}
+
+void Gateway::process_event(td::td_api::object_ptr<td::td_api::updateCall> update_call) {
+
+    auto iter = search_call([id = update_call->call_->id_](const Bridge *bridge) {
+        return bridge->ctx->tg_call_id == id;
+    });
+
+    (*iter)->sm->process_event(update_call);
+
+    if ((*iter)->sm->is(sml::X)) {
+        delete *iter;
+        bridges.erase(iter);
+    }
+}
+
+void Gateway::process_event(td::td_api::object_ptr<td::td_api::updateNewMessage> update_message) {
+
+    std::vector<Bridge *> matches;
+    for (auto bridge : bridges) {
+        if (bridge->ctx->user_id == update_message->message_->sender_user_id_) {
+            matches.emplace_back(bridge);
+        }
+    }
+
+    if (matches.size() > 1) {
+        logger_->error("ambiguous message from {}", update_message->message_->sender_user_id_);
+        return;
+    } else if (matches.size() == 1) {
+        TRACE(logger_, "routing message to ctx {}", matches[0]->ctx->id());
+        matches[0]->sm->process_event(update_message);
+    }
+
+}
+
+void Gateway::process_event(state_machine::events::InternalError &event) {
+    auto iter = std::find_if(bridges.begin(), bridges.end(), [id = event.ctx_id](const Bridge *bridge) {
+        return bridge->ctx->id() == id;
+    });
+
+    if (iter == bridges.end()) {
+        return;
+    }
+
+    (*iter)->sm->process_event(event);
+
+    if ((*iter)->sm->is(sml::X)) {
+        delete *iter;
+        bridges.erase(iter);
+    }
+
+}
+
+template<typename TSipEvent>
+void Gateway::process_event(const TSipEvent &event) {
+
+    auto iter = search_call([id = event.id](const Bridge *bridge) {
+        return bridge->ctx->sip_call_id == id;
+    });
+
+    (*iter)->sm->process_event(event);
+
+    if ((*iter)->sm->is(sml::X)) {
+        delete *iter;
+        bridges.erase(iter);
+    }
+}
\ No newline at end of file
diff --git a/tg2sip/gateway.h b/tg2sip/gateway.h
new file mode 100755
index 0000000..9274b4e
--- /dev/null
+++ b/tg2sip/gateway.h
@@ -0,0 +1,306 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef TG2SIP_GATEWAY_H
+#define TG2SIP_GATEWAY_H
+
+#include <stdexcept>
+#include <regex>
+#include <libtgvoip/VoIPController.h>
+#include <boost/sml.hpp>
+#include <csignal>
+#include "sip.h"
+#include "tg.h"
+#include "utils.h"
+#include "queue.h"
+
+namespace sml = boost::sml;
+
+class Context;
+
+struct Cache;
+
+namespace state_machine::events {
+
+    struct InternalError {
+        std::string ctx_id;
+        pj::CallOpParam prm;
+    };
+
+    typedef std::variant<InternalError> Event;
+}
+
+namespace state_machine::guards {
+    struct IsIncoming {
+        bool operator()(const td::td_api::object_ptr<td::td_api::updateCall> &event) const;
+    };
+
+    class IsInState {
+    public:
+        explicit IsInState(int32_t id) : id_(id) {}
+
+        bool operator()(const td::td_api::object_ptr<td::td_api::updateCall> &event) const;
+
+    private:
+        const int32_t id_;
+    };
+
+    class IsSipInState {
+    public:
+        explicit IsSipInState(pjsip_inv_state state) : state_(state) {}
+
+        bool operator()(const sip::events::CallStateUpdate &event) const;
+
+    private:
+        const pjsip_inv_state state_;
+    };
+
+    struct CallbackUriIsSet {
+        bool operator()(const Settings &settings) const;
+    };
+
+    struct IsMediaReady {
+        bool operator()(const sip::events::CallMediaStateUpdate &event) const;
+    };
+
+    struct IsTextContent {
+        bool operator()(const td::td_api::object_ptr<td::td_api::updateNewMessage> &event) const;
+    };
+
+    struct IsDtmfString {
+        bool operator()(const td::td_api::object_ptr<td::td_api::updateNewMessage> &event) const;
+    };
+}
+
+namespace state_machine::actions {
+
+    struct StoreTgId {
+        void operator()(Context &ctx, const td::td_api::object_ptr<td::td_api::updateCall> &event,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct StoreTgUserId {
+        void operator()(Context &ctx, const td::td_api::object_ptr<td::td_api::updateCall> &event,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct CleanTgId {
+        void operator()(Context &ctx) const;
+    };
+
+    struct CleanSipId {
+        void operator()(Context &ctx) const;
+    };
+
+    struct StoreSipId {
+        void operator()(Context &ctx, const sip::events::IncomingCall &event,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct DialSip {
+        void operator()(Context &ctx, tg::Client &tg_client, sip::Client &sip_client,
+                        const td::td_api::object_ptr<td::td_api::updateCall> &event,
+                        OptionalQueue<state_machine::events::Event> &internal_events,
+                        const Settings &settings, std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct AnswerTg {
+        void operator()(Context &ctx, tg::Client &tg_client, const Settings &settings,
+                        OptionalQueue<state_machine::events::Event> &internal_events,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct AcceptIncomingSip {
+        void operator()(Context &ctx, sip::Client &sip_client, const Settings &settings,
+                        const sip::events::IncomingCall &event,
+                        OptionalQueue<state_machine::events::Event> &internal_events,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct AnswerSip {
+        void operator()(Context &ctx, sip::Client &sip_client, const Settings &settings,
+                        OptionalQueue<state_machine::events::Event> &internal_events,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct BridgeAudio {
+        void operator()(Context &ctx, sip::Client &sip_client,
+                        OptionalQueue<state_machine::events::Event> &internal_events,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct CreateTgVoip {
+        void operator()(Context &ctx, const Settings &settings,
+                        const td::td_api::object_ptr<td::td_api::updateCall> &event,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct CleanUp {
+        void operator()(Context &ctx, sip::Client &sip_client, tg::Client &tg_client,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+
+    struct SetHangupPrm {
+        void operator()(Context &ctx, const state_machine::events::InternalError &event) const;
+    };
+
+    class DialTg {
+    private:
+        Context *ctx_;
+        tg::Client *tg_client_;
+        Settings const *settings_;
+        Cache *cache_;
+        std::chrono::steady_clock::time_point *block_until_;
+        OptionalQueue<state_machine::events::Event> *internal_events_;
+        std::shared_ptr<spdlog::logger> logger_;
+
+        void parse_error(td::td_api::object_ptr<td::td_api::error> error);
+
+        void dial_by_id(int32_t id);
+
+        void dial_by_phone();
+
+        void dial_by_username();
+
+    public:
+        void operator()(Context &ctx, tg::Client &tg_client, const Settings &settings, Cache &cache,
+                        std::chrono::steady_clock::time_point &block_until,
+                        OptionalQueue<state_machine::events::Event> &internal_events,
+                        std::shared_ptr<spdlog::logger> logger);
+    };
+
+    struct DialDtmf {
+        void operator()(Context &ctx, sip::Client &sip_client,
+                        const td::td_api::object_ptr<td::td_api::updateNewMessage> &event,
+                        std::shared_ptr<spdlog::logger> logger) const;
+    };
+}
+
+namespace state_machine {
+    class Logger {
+    public:
+        Logger(std::string context_id, shared_ptr<spdlog::logger> logger);
+
+        virtual ~Logger();
+
+        template<class SM>
+        void log_process_event(const td::td_api::object_ptr<td::td_api::updateCall> &event);
+
+        template<class SM>
+        void log_process_event(const sip::events::Event &event);
+
+        template<class SM, class TEvent>
+        void log_process_event(const TEvent &);
+
+        template<class SM, class TGuard, class TEvent>
+        void log_guard(const TGuard &, const TEvent &event, bool result);
+
+        template<class SM, class TAction, class TEvent>
+        void log_action(const TAction &, const TEvent &event);
+
+        template<class SmLogger, class TSrcState, class TDstState>
+        void log_state_change(const TSrcState &src, const TDstState &dst);
+
+    private:
+        const std::string context_id_;
+        std::shared_ptr<spdlog::logger> logger_;
+    };
+
+    struct StateMachine;
+
+    typedef sml::sm<StateMachine, sml::logger<Logger>, sml::thread_safe<std::recursive_mutex>> sm_t;
+}
+
+struct Cache {
+    std::map<std::string, int32_t> username_cache;
+    std::map<std::string, int32_t> phone_cache;
+};
+
+class Context {
+public:
+    Context();
+
+    const std::string id() const;
+
+    pjsua_call_id sip_call_id{PJSUA_INVALID_ID};
+    int32_t tg_call_id{0};
+    std::shared_ptr<tgvoip::VoIPController> controller{nullptr};
+
+    std::string ext_phone;
+    std::string ext_username;
+    int32_t user_id{0};
+
+    pj::CallOpParam hangup_prm;
+
+private:
+    const std::string id_;
+
+    std::string next_ctx_id();
+};
+
+struct Bridge {
+    std::unique_ptr<state_machine::sm_t> sm;
+    std::unique_ptr<Context> ctx;
+    std::unique_ptr<state_machine::Logger> logger;
+};
+
+class Gateway {
+public:
+    Gateway(sip::Client &sip_client_, tg::Client &tg_client_,
+            OptionalQueue<sip::events::Event> &sip_events_,
+            OptionalQueue<tg::Client::Object> &tg_events_,
+            std::shared_ptr<spdlog::logger> logger_,
+            Settings &settings);
+
+    Gateway(const Gateway &) = delete;
+
+    Gateway &operator=(const Gateway &) = delete;
+
+    void start(volatile sig_atomic_t e_flag);
+
+private:
+    std::shared_ptr<spdlog::logger> logger_;
+
+    sip::Client &sip_client_;
+    tg::Client &tg_client_;
+    const Settings &settings_;
+
+    OptionalQueue<sip::events::Event> &sip_events_;
+    OptionalQueue<tg::Client::Object> &tg_events_;
+    OptionalQueue<state_machine::events::Event> internal_events_;
+
+    std::chrono::steady_clock::time_point block_until{std::chrono::steady_clock::now()};
+    Cache cache_;
+    // Would be better to use smart pointer here,
+    // but it is not allowed by sm_t forward declaration
+    std::vector<Bridge *> bridges;
+
+    std::vector<Bridge *>::iterator search_call(const std::function<bool(const Bridge *)> &predicate);
+
+    void process_event(td::td_api::object_ptr<td::td_api::updateCall> update_call);
+
+    void process_event(td::td_api::object_ptr<td::td_api::updateNewMessage> update_message);
+
+    void process_event(state_machine::events::InternalError &event);
+
+    template<typename TSipEvent>
+    void process_event(const TSipEvent &event);
+
+    void load_cache();
+};
+
+#endif //TG2SIP_GATEWAY_H
diff --git a/tg2sip/gen_db.cpp b/tg2sip/gen_db.cpp
new file mode 100644
index 0000000..35bf917
--- /dev/null
+++ b/tg2sip/gen_db.cpp
@@ -0,0 +1,243 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+#include <INIReader.h>
+#include <td/telegram/Client.h>
+#include <td/telegram/Log.h>
+#include <functional>
+#include <map>
+#include "settings.h"
+
+// overloaded
+namespace detail {
+    template<class... Fs>
+    struct overload;
+
+    template<class F>
+    struct overload<F> : public F {
+        explicit overload(F f) : F(f) {
+        }
+    };
+
+    template<class F, class... Fs>
+    struct overload<F, Fs...>
+            : public overload<F>, overload<Fs...> {
+        overload(F f, Fs... fs) : overload<F>(f), overload<Fs...>(fs...) {
+        }
+
+        using overload<F>::operator();
+        using overload<Fs...>::operator();
+    };
+}  // namespace detail
+
+template<class... F>
+auto overloaded(F... f) {
+    return detail::overload<F...>(f...);
+}
+
+namespace td_api = td::td_api;
+
+class TDClient {
+public:
+    explicit TDClient(Settings &settings_) : settings(settings_) {
+        td::Log::set_verbosity_level(1);
+        client = std::make_unique<td::Client>();
+    }
+
+    void auth() {
+        while (!sequence_done) {
+            process_response(client->receive(10));
+        }
+    }
+
+private:
+    using Object = td_api::object_ptr<td_api::Object>;
+
+    Settings &settings;
+    bool sequence_done{false};
+
+    std::unique_ptr<td::Client> client;
+    td_api::object_ptr<td_api::AuthorizationState> authorization_state;
+
+    std::uint64_t current_query_id{0};
+    std::uint64_t authentication_query_id{0};
+    std::map<std::uint64_t, std::function<void(Object)>> handlers;
+
+    std::uint64_t next_query_id() {
+        return ++current_query_id;
+    }
+
+    void send_query(td_api::object_ptr<td_api::Function> f, std::function<void(Object)> handler) {
+        auto query_id = next_query_id();
+        if (handler) {
+            handlers.emplace(query_id, std::move(handler));
+        }
+        client->send({query_id, std::move(f)});
+    }
+
+    void process_response(td::Client::Response response) {
+        if (!response.object) {
+            return;
+        }
+
+        if (response.id == 0) {
+            return process_update(std::move(response.object));
+        }
+
+        auto it = handlers.find(response.id);
+        if (it != handlers.end()) {
+            it->second(std::move(response.object));
+            handlers.erase(it->first);
+        }
+    }
+
+    void process_update(td_api::object_ptr<td_api::Object> update) {
+        td_api::downcast_call(
+                *update, overloaded(
+                        [this](td_api::updateAuthorizationState &update_authorization_state) {
+                            authorization_state = std::move(update_authorization_state.authorization_state_);
+                            on_authorization_state_update();
+                        },
+                        [](auto &update) {}));
+    }
+
+    auto create_authentication_query_handler() {
+        return [this, id = authentication_query_id](Object object) {
+            if (id == authentication_query_id) {
+                check_authentication_error(std::move(object));
+            }
+        };
+    }
+
+    void check_authentication_error(Object object) {
+        if (object->get_id() == td_api::error::ID) {
+            auto error = td::move_tl_object_as<td_api::error>(object);
+            std::cerr << "Error: " << to_string(error);
+            on_authorization_state_update();
+        }
+    }
+
+    void on_authorization_state_update() {
+        authentication_query_id++;
+        td_api::downcast_call(
+                *authorization_state,
+                overloaded(
+                        [this](td_api::authorizationStateReady &) {
+                            sequence_done = true;
+                            std::cerr << "Authorization OK" << std::endl;
+                        },
+                        [this](td_api::authorizationStateLoggingOut &) {
+                            sequence_done = true;
+                            std::cerr << "Logging out" << std::endl;
+                        },
+                        [this](td_api::authorizationStateClosing &) {
+                            std::cerr << "Closing" << std::endl;
+                        },
+                        [this](td_api::authorizationStateClosed &) {
+                            sequence_done = true;
+                            std::cerr << "Terminated" << std::endl;
+                        },
+                        [this](td_api::authorizationStateWaitCode &wait_code) {
+                            std::string first_name;
+                            std::string last_name;
+                            if (!wait_code.is_registered_) {
+                                std::cerr << "Enter your first name: ";
+                                std::cin >> first_name;
+                                std::cerr << "Enter your last name: ";
+                                std::cin >> last_name;
+                            }
+                            std::cerr << "Enter authentication code: ";
+                            std::string code;
+                            std::cin >> code;
+                            send_query(
+                                    td_api::make_object<td_api::checkAuthenticationCode>(code, first_name, last_name),
+                                    create_authentication_query_handler());
+                        },
+                        [this](td_api::authorizationStateWaitPassword &) {
+                            std::cerr << "Enter authentication password: ";
+                            std::string password;
+                            std::cin >> password;
+                            send_query(td_api::make_object<td_api::checkAuthenticationPassword>(password),
+                                       create_authentication_query_handler());
+                        },
+                        [this](td_api::authorizationStateWaitPhoneNumber &) {
+                            std::cerr << "Enter phone number: ";
+                            std::string phone_number;
+                            std::cin >> phone_number;
+                            send_query(td_api::make_object<td_api::setAuthenticationPhoneNumber>(
+                                    phone_number, false /*allow_flash_calls*/, false /*is_current_phone_number*/),
+                                       create_authentication_query_handler());
+                        },
+                        [this](td_api::authorizationStateWaitEncryptionKey &) {
+                            send_query(td_api::make_object<td_api::checkDatabaseEncryptionKey>(""),
+                                       create_authentication_query_handler());
+
+                            td_api::object_ptr<td_api::Proxy> proxy;
+                            if (settings.proxy_enabled()) {
+                                auto socks_proxy = td_api::make_object<td_api::proxySocks5>(
+                                        settings.proxy_address(),
+                                        settings.proxy_port(),
+                                        settings.proxy_username(),
+                                        settings.proxy_password()
+                                );
+                                proxy = td_api::move_object_as<td_api::Proxy>(socks_proxy);
+                            } else {
+                                auto empty_proxy = td_api::make_object<td_api::proxyEmpty>();
+                                proxy = td_api::move_object_as<td_api::Proxy>(empty_proxy);
+                            }
+                            send_query(td_api::make_object<td_api::setProxy>(
+                                    td_api::move_object_as<td_api::Proxy>(proxy)),
+                                       [](Object) {});
+                        },
+                        [this](td_api::authorizationStateWaitTdlibParameters &) {
+                            auto lib_parameters = td_api::make_object<td_api::tdlibParameters>();
+                            lib_parameters = td_api::make_object<td_api::tdlibParameters>();
+
+                            lib_parameters->api_id_ = settings.api_id();
+                            lib_parameters->api_hash_ = settings.api_hash();
+                            lib_parameters->database_directory_ = settings.db_folder();
+
+                            lib_parameters->system_language_code_ = settings.sys_lang_code();
+                            lib_parameters->device_model_ = settings.device_model();
+                            lib_parameters->system_version_ = settings.system_version();
+                            lib_parameters->application_version_ = settings.app_version();
+
+                            lib_parameters->use_file_database_ = false;
+                            lib_parameters->use_chat_info_database_ = true;
+                            lib_parameters->use_message_database_ = false;
+                            lib_parameters->use_secret_chats_ = false;
+                            lib_parameters->enable_storage_optimizer_ = true;
+
+                            send_query(td_api::make_object<td_api::setTdlibParameters>(std::move(lib_parameters)),
+                                       create_authentication_query_handler());
+                        }));
+    }
+};
+
+int main() {
+
+    auto reader = INIReader("settings.ini");
+    Settings settings(reader);
+
+    if (!settings.is_loaded()) {
+        return 1;
+    }
+
+    TDClient client(settings);
+    client.auth();
+}
\ No newline at end of file
diff --git a/tg2sip/logging.cpp b/tg2sip/logging.cpp
new file mode 100755
index 0000000..8a51353
--- /dev/null
+++ b/tg2sip/logging.cpp
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+#include <td/telegram/Log.h>
+#include "logging.h"
+
+void init_logging(Settings &settings) {
+
+    try {
+        std::vector<spdlog::sink_ptr> sinks;
+
+        auto console_sink = std::make_shared<spdlog::sinks::ansicolor_stdout_sink_mt>();
+        console_sink->set_level(static_cast<spdlog::level::level_enum>(settings.console_min_level()));
+        sinks.push_back(std::move(console_sink));
+
+        auto file_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>("tg2sip.log", 100 * 1024 * 1024, 1);
+        file_sink->set_level(static_cast<spdlog::level::level_enum>(settings.file_min_level()));
+        sinks.push_back(std::move(file_sink));
+
+        std::vector<string> loggers;
+        loggers.emplace_back("core");
+        loggers.emplace_back("pjsip");
+        loggers.emplace_back("tgvoip");
+
+        for (auto log_name : loggers) {
+            auto logger = std::make_shared<spdlog::logger>(log_name, begin(sinks), end(sinks));
+            spdlog::register_logger(logger);
+        }
+
+#ifndef DISABLE_DEBUG_
+        spdlog::set_pattern("%^[%T.%e][t:%t][p:%P][%n][%l] %v%$");
+#endif
+
+        spdlog::apply_all([&](std::shared_ptr<spdlog::logger> l) {
+            l->set_level(spdlog::level::info);
+        });
+
+    }
+    catch (const spdlog::spdlog_ex &ex) {
+        std::cerr << ex.what() << std::endl;
+    }
+
+    td::Log::set_file_path("tdlib.log");
+    td::Log::set_verbosity_level(settings.tdlib_log_level());
+
+    spdlog::get("core")->set_level(static_cast<spdlog::level::level_enum>(settings.log_level()));
+    spdlog::get("pjsip")->set_level(static_cast<spdlog::level::level_enum>(settings.pjsip_log_level()));
+    spdlog::get("tgvoip")->set_level(static_cast<spdlog::level::level_enum>(settings.tgvoip_log_level()));
+
+}
\ No newline at end of file
diff --git a/tg2sip/logging.h b/tg2sip/logging.h
new file mode 100755
index 0000000..f29d065
--- /dev/null
+++ b/tg2sip/logging.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef TG2SIP_LOGGING_H
+#define TG2SIP_LOGGING_H
+
+#include <spdlog/spdlog.h>
+#include <spdlog/fmt/ostr.h>
+#include "settings.h"
+
+#ifndef DISABLE_DEBUG_
+#define STRINGIZE_(x) #x
+#define STRINGIZE(x) STRINGIZE_(x)
+#define TRACE(logger, ...) logger->trace("" __FILE__  ":" STRINGIZE(__LINE__)" " __VA_ARGS__)
+#define DEBUG(logger, ...) logger->debug(__VA_ARGS__)
+#else
+#define TRACE(logger, ...) (void)0
+#define DEBUG(logger, ...) (void)0
+#endif
+
+void init_logging(Settings &settings);
+
+#endif //TG2SIP_LOGGING_H
diff --git a/tg2sip/main.cpp b/tg2sip/main.cpp
new file mode 100755
index 0000000..01acf4c
--- /dev/null
+++ b/tg2sip/main.cpp
@@ -0,0 +1,92 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <thread>
+#include <iostream>
+#include <csignal>
+#include <variant>
+#include "logging.h"
+#include "queue.h"
+#include "utils.h"
+#include "tg.h"
+#include "sip.h"
+#include "gateway.h"
+
+volatile sig_atomic_t e_flag = 0;
+
+int main() {
+    pthread_setname_np(pthread_self(), "main");
+
+    auto reader = INIReader("settings.ini");
+    Settings settings(reader);
+
+    if (!settings.is_loaded()) {
+        return 1;
+    }
+
+    init_logging(settings);
+
+    std::set_terminate([]() {
+        auto exc = std::current_exception();
+        try {
+            rethrow_exception(exc);
+        } catch (std::exception &e) {
+            spdlog::get("core")->critical("Unhandled exception: {}", e.what());
+        }
+        spdlog::drop_all();
+        std::abort();
+    });
+
+    auto logger = spdlog::get("core");
+
+    OptionalQueue<sip::events::Event> sip_events;
+    /* will be removed on pj endpoint destroy */
+    auto sip_log_writer = new sip::LogWriter(spdlog::get("pjsip"));
+    auto sip_account = std::make_unique<sip::Account>(logger);
+    auto sip_account_cfg = std::make_unique<sip::AccountConfig>(settings);
+    auto sip_client = std::make_unique<sip::Client>(
+            std::move(sip_account),
+            std::move(sip_account_cfg),
+            sip_events,
+            settings,
+            logger,
+            sip_log_writer
+    );
+    sip_client->start();
+
+    OptionalQueue<tg::Client::Object> tg_events;
+    auto tg_client = std::make_unique<tg::Client>(settings, logger, tg_events);
+    tg_client->start();
+    auto tg_is_ready_future = tg_client->is_ready();
+    auto tg_status = tg_is_ready_future.wait_for(std::chrono::seconds(5));
+    if (tg_status != std::future_status::ready || !tg_is_ready_future.get()) {
+        logger->critical("failed to start TG client");
+        return 1;
+    }
+
+    auto gateway = std::make_unique<Gateway>(*sip_client, *tg_client, sip_events, tg_events, logger, settings);
+
+    signal(SIGINT, [](int) { e_flag = 1; });
+    signal(SIGTERM, [](int) { e_flag = 1; });
+
+    gateway->start(e_flag);
+
+    logger->info("performing a graceful shutdown...");
+    spdlog::drop_all();
+
+    return 0;
+}
\ No newline at end of file
diff --git a/tg2sip/queue.h b/tg2sip/queue.h
new file mode 100755
index 0000000..bfe1fa0
--- /dev/null
+++ b/tg2sip/queue.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef TG2SIP_QUEUE_H
+#define TG2SIP_QUEUE_H
+
+#include <mutex>
+#include <queue>
+#include <condition_variable>
+
+template<typename T>
+class OptionalQueue {
+public:
+    OptionalQueue() = default;
+
+    OptionalQueue(const OptionalQueue &) = delete;
+
+    OptionalQueue &operator=(const OptionalQueue &) = delete;
+
+    virtual ~OptionalQueue() = default;
+
+    void emplace(std::optional<T> &&value) {
+        {
+            std::unique_lock<std::mutex> lock(this->mutex);
+            q.emplace(std::move(value));
+        }
+    };
+
+    std::optional<T> pop() {
+        std::unique_lock<std::mutex> lock(this->mutex);
+
+        if (q.empty()) {
+            return std::nullopt;
+        }
+
+        std::optional<T> value = std::move(this->q.front());
+        this->q.pop();
+
+        return value;
+    };
+
+private:
+    std::queue<std::optional<T>> q;
+    std::mutex mutex;
+};
+
+#endif //TG2SIP_QUEUE_H
diff --git a/tg2sip/settings.cpp b/tg2sip/settings.cpp
new file mode 100755
index 0000000..dc104d7
--- /dev/null
+++ b/tg2sip/settings.cpp
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <iostream>
+#include <thread>
+#include "settings.h"
+
+Settings::Settings(INIReader &reader) {
+
+    if (reader.ParseError() < 0) {
+        std::cerr << "Can't load settings file!\n";
+        return;
+    }
+
+    // logging
+    console_min_level_ = std::clamp(static_cast<int>(reader.GetInteger("logging", "console_min_level", 0)), 0, 6);
+    file_min_level_ = std::clamp(static_cast<int>(reader.GetInteger("logging", "file_min_level", 0)), 0, 6);
+    log_level_ = std::clamp(static_cast<int>(reader.GetInteger("logging", "core", 2)), 0, 6);
+    tdlib_log_level_ = std::clamp(static_cast<int>(reader.GetInteger("logging", "tdlib", 3)), 0, 6);
+    tgvoip_log_level_ = std::clamp(static_cast<int>(reader.GetInteger("logging", "tgvoip", 5)), 0, 6);
+    pjsip_log_level_ = std::clamp(static_cast<int>(reader.GetInteger("logging", "pjsip", 2)), 0, 6);
+    pjsip_log_sip_messages_ = reader.GetBoolean("logging", "sip_messages", true);
+
+    // sip
+    sip_port_ = static_cast<unsigned int>(reader.GetInteger("sip", "port", 0));
+    id_uri_ = reader.Get("sip", "id_uri", "sip:localhost");
+    callback_uri_ = reader.Get("sip", "callback_uri", "");
+    public_address_ = reader.Get("sip", "public_address", "");
+    stun_server_ = reader.Get("sip", "stun_server", "");
+    raw_pcm_ = reader.GetBoolean("sip", "raw_pcm", true);
+    sip_thread_count_ = static_cast<unsigned int>(reader.GetInteger("sip", "thread_count", 1));
+    sip_port_range_ = static_cast<unsigned int>(reader.GetInteger("sip", "port_range", 0));
+
+    //telegram
+    api_id_ = static_cast<int>(reader.GetInteger("telegram", "api_id", 0));
+    api_hash_ = reader.Get("telegram", "api_hash", "");
+    db_folder_ = reader.Get("telegram", "database_folder", "");
+    system_language_code_ = reader.Get("telegram", "database_folder", "en-US");
+    device_model_ = reader.Get("telegram", "device_model", "PC");
+    system_version_ = reader.Get("telegram", "system_version", "Linux");
+    application_version_ = reader.Get("telegram", "application_version", "1.0");
+
+    udp_p2p_ = reader.GetBoolean("telegram", "udp_p2p", false);
+    udp_reflector_ = reader.GetBoolean("telegram", "udp_reflector", true);
+
+    aec_enabled_ = reader.GetBoolean("telegram", "enable_aec", false);
+    ns_enabled_ = reader.GetBoolean("telegram", "enable_ns", false);
+    agc_enabled_ = reader.GetBoolean("telegram", "enable_agc", false);
+
+    proxy_enabled_ = reader.GetBoolean("telegram", "use_proxy", false);
+    proxy_address_ = reader.Get("telegram", "proxy_address", "");
+    proxy_port_ = static_cast<int32_t>(reader.GetInteger("telegram", "proxy_port", 0));
+    proxy_username_ = reader.Get("telegram", "proxy_username", "");
+    proxy_password_ = reader.Get("telegram", "proxy_password", "");
+
+    voip_proxy_enabled_ = reader.GetBoolean("telegram", "use_voip_proxy", false);
+    voip_proxy_address_ = reader.Get("telegram", "voip_proxy_address", "");
+    voip_proxy_port_ = static_cast<uint16_t>(reader.GetInteger("telegram", "voip_proxy_port", 0));
+    voip_proxy_username_ = reader.Get("telegram", "voip_proxy_username", "");
+    voip_proxy_password_ = reader.Get("telegram", "voip_proxy_password", "");
+
+    extra_wait_time_ = static_cast<unsigned int>(reader.GetInteger("other", "extra_wait_time", 30));
+    peer_flood_time_ = static_cast<unsigned int>(reader.GetInteger("other", "peer_flood_time", 86400));
+
+    if (api_id_ == 0 || api_hash_.empty()) {
+        std::cerr << "TDLib api settings must be set!\n";
+        return;
+    }
+
+    is_loaded_ = true;
+}
diff --git a/tg2sip/settings.h b/tg2sip/settings.h
new file mode 100755
index 0000000..d1ee00f
--- /dev/null
+++ b/tg2sip/settings.h
@@ -0,0 +1,162 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef TG2SIP_SETTINGS_H
+#define TG2SIP_SETTINGS_H
+
+#include <INIReader.h>
+
+class Settings {
+private:
+    bool is_loaded_{false};
+
+    int console_min_level_;
+    int file_min_level_;
+    int log_level_;
+    int pjsip_log_level_;
+    bool pjsip_log_sip_messages_;
+    int tgvoip_log_level_;
+    int tdlib_log_level_;
+
+    unsigned int sip_port_;
+    std::string id_uri_;
+    std::string callback_uri_;
+    std::string public_address_;
+    std::string stun_server_;
+    bool raw_pcm_;
+    unsigned int sip_thread_count_;
+    unsigned int sip_port_range_;
+
+    int api_id_;
+    std::string api_hash_;
+    std::string db_folder_;
+    std::string system_language_code_;
+    std::string device_model_;
+    std::string system_version_;
+    std::string application_version_;
+
+    bool udp_p2p_;
+    bool udp_reflector_;
+
+    bool aec_enabled_;
+    bool ns_enabled_;
+    bool agc_enabled_;
+
+    bool proxy_enabled_;
+    std::string proxy_address_;
+    std::int32_t proxy_port_;
+    std::string proxy_username_;
+    std::string proxy_password_;
+
+    bool voip_proxy_enabled_;
+    std::string voip_proxy_address_;
+    uint16_t voip_proxy_port_;
+    std::string voip_proxy_username_;
+    std::string voip_proxy_password_;
+
+    unsigned int extra_wait_time_;
+    unsigned int peer_flood_time_;
+
+public:
+    explicit Settings(INIReader &reader);
+
+    Settings(const Settings &) = delete;
+
+    Settings &operator=(const Settings &) = delete;
+
+    bool is_loaded() const { return is_loaded_; };
+
+    int console_min_level() const { return console_min_level_; };
+
+    int file_min_level() const { return file_min_level_; };
+
+    int log_level() const { return log_level_; };
+
+    int pjsip_log_level() const { return pjsip_log_level_; };
+
+    bool pjsip_log_sip_messages() const { return pjsip_log_sip_messages_; }
+
+    int tgvoip_log_level() const { return tgvoip_log_level_; };
+
+    int tdlib_log_level() const { return tdlib_log_level_; };
+
+    unsigned int sip_port() const { return sip_port_; };
+
+    string id_uri() const { return id_uri_; };
+
+    string callback_uri() const { return callback_uri_; };
+
+    string public_address() const { return public_address_; };
+
+    string stun_server() const { return stun_server_; };
+
+    bool raw_pcm() const { return raw_pcm_; };
+
+    unsigned int sip_thread_count() const { return sip_thread_count_; };
+
+    unsigned int sip_port_range() const { return sip_port_range_; };
+
+    int api_id() const { return api_id_; };
+
+    std::string api_hash() const { return api_hash_; };
+
+    std::string db_folder() const { return db_folder_; };
+
+    std::string sys_lang_code() const { return system_language_code_; };
+
+    std::string device_model() const { return device_model_; };
+
+    std::string system_version() const { return system_version_; };
+
+    std::string app_version() const { return application_version_; };
+
+    bool udp_p2p() const { return udp_p2p_; };
+
+    bool udp_reflector() const { return udp_reflector_; };
+
+    bool aec_enabled() const { return aec_enabled_; };
+
+    bool ns_enabled() const { return ns_enabled_; };
+
+    bool agc_enabled() const { return agc_enabled_; };
+
+    bool proxy_enabled() const { return proxy_enabled_; };
+
+    std::string proxy_address() const { return proxy_address_; };
+
+    int32_t proxy_port() const { return proxy_port_; };
+
+    std::string proxy_username() const { return proxy_username_; };
+
+    std::string proxy_password() const { return proxy_password_; };
+
+    bool voip_proxy_enabled() const { return voip_proxy_enabled_; };
+
+    std::string voip_proxy_address() const { return voip_proxy_address_; };
+
+    uint16_t voip_proxy_port() const { return voip_proxy_port_; };
+
+    std::string voip_proxy_username() const { return voip_proxy_username_; };
+
+    std::string voip_proxy_password() const { return voip_proxy_password_; };
+
+    unsigned int extra_wait_time() const { return extra_wait_time_; };
+
+    unsigned int peer_flood_time() const { return peer_flood_time_; };
+};
+
+#endif //TG2SIP_SETTINGS_H
diff --git a/tg2sip/sip.cpp b/tg2sip/sip.cpp
new file mode 100755
index 0000000..06672a6
--- /dev/null
+++ b/tg2sip/sip.cpp
@@ -0,0 +1,312 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "sip.h"
+
+using namespace sip;
+
+void LogWriter::write(const pj::LogEntry &entry) {
+    auto msg = entry.msg;
+    // 6 = DTRACE, 5 = TRACE, ... , 0 = FATAL
+    int spd_log_level = entry.level > 5 ? 0 : 5 - entry.level;
+    logger->log(static_cast<spdlog::level::level_enum>(spd_log_level), msg);
+}
+
+AccountConfig::AccountConfig(Settings &settings) {
+
+    idUri = settings.id_uri();
+
+    // in case SIP timer RFC4028 is used
+    // required when registration is used
+    callConfig.timerMinSESec = 120;
+    callConfig.timerSessExpiresSec = 1800;
+}
+
+void Account::addHandler(std::function<void(pj::OnIncomingCallParam &)> &&handler) {
+    onIncomingCallHandler = std::move(handler);
+}
+
+void Account::onIncomingCall(pj::OnIncomingCallParam &prm) {
+    if (onIncomingCallHandler) {
+        onIncomingCallHandler(prm);
+    }
+}
+
+Call::Call(pj::Account &acc, std::shared_ptr<spdlog::logger> logger, int call_id = PJSUA_INVALID_ID)
+        : pj::Call(acc, call_id),
+          logger(std::move(logger)) {}
+
+Call::~Call() {
+    TRACE(logger, "~Call {}", getId());
+}
+
+void Call::addHandler(std::function<void(pj::OnCallStateParam &)> &&handler) {
+    onCallStateHandler = std::move(handler);
+}
+
+void Call::addHandler(std::function<void(pj::OnCallMediaStateParam &)> &&handler) {
+    onCallMediaStateHandler = std::move(handler);
+}
+
+pj::AudioMedia *Call::audio_media() {
+
+    pj::AudioMedia *aud_med{nullptr};
+
+    auto ci = getInfo();
+
+    for (unsigned i = 0; i < ci.media.size(); i++) {
+        if (ci.media[i].type == PJMEDIA_TYPE_AUDIO && getMedia(i)) {
+            aud_med = dynamic_cast<pj::AudioMedia *>(getMedia(i));
+            break;
+        }
+    }
+
+    return aud_med;
+}
+
+void Call::onCallState(pj::OnCallStateParam &prm) {
+    if (onCallStateHandler) {
+        onCallStateHandler(prm);
+    }
+}
+
+void Call::onCallMediaState(pj::OnCallMediaStateParam &prm) {
+    if (onCallMediaStateHandler) {
+        onCallMediaStateHandler(prm);
+    }
+}
+
+const string Call::localUser() {
+    return local_user_;
+}
+
+Client::Client(std::unique_ptr<Account> account_, std::unique_ptr<AccountConfig> account_cfg_,
+                     OptionalQueue<events::Event> &events_, Settings &settings,
+                     std::shared_ptr<spdlog::logger> logger_, LogWriter *sip_log_writer)
+        : account(std::move(account_)),
+          account_cfg(std::move(account_cfg_)),
+          events(events_),
+          logger(std::move(logger_)) {
+
+    // magic statics yay!
+    static auto ep = std::make_unique<pj::Endpoint>();
+
+    if (ep->libGetState() == PJSUA_STATE_NULL) {
+        init_pj_endpoint(settings, sip_log_writer);
+    }
+
+    account->addHandler([this](pj::OnIncomingCallParam &prm) {
+        auto call = std::make_shared<Call>(*account, logger, prm.callId);
+        auto ci = call->getInfo();
+
+        call->local_user_ = user_from_uri(ci.localUri);
+        calls.emplace(call->getId(), call);
+
+        set_default_handlers(call);
+
+        DEBUG(logger, "incoming SIP call #{} from {} to {} with call-id {}", ci.id, ci.remoteUri, ci.localUri,
+              ci.callIdString);
+
+        events.emplace(events::IncomingCall{ci.id, call->localUser()});
+    });
+
+}
+
+Client::~Client() {
+    TRACE(logger, "~Client");
+}
+
+void Client::init_pj_endpoint(Settings &settings, LogWriter *sip_log_writer) {
+    using namespace pj;
+
+    auto log_writer = sip_log_writer;
+    auto &ep = pj::Endpoint::instance();
+
+    // Hide logs before pjsua2 init
+    pj_log_set_level(0);
+
+    ep.libCreate();
+
+    EpConfig ep_cfg;
+    if (!settings.pjsip_log_sip_messages()) {
+        // don't log SIP messages
+        ep_cfg.logConfig.msgLogging = 0;
+    }
+    ep_cfg.logConfig.consoleLevel = 6;
+
+    // TODO: partially remove decor. Leave filename. Could require pjsip recompile.
+    ep_cfg.logConfig.decor = 0;
+    ep_cfg.logConfig.writer = log_writer;
+
+    // https://trac.pjsip.org/repos/wiki/FAQ#high-perf
+    // disable echo canceller
+    ep_cfg.medConfig.ecTailLen = 0;
+    // set SIP threads number
+    ep_cfg.medConfig.threadCnt = settings.sip_thread_count();
+
+    // 10ms ptime required to keep L16 RTP packet below MTU
+    ep_cfg.medConfig.audioFramePtime = 10;
+    ep_cfg.medConfig.ptime = 10;
+
+    // must be the same as used in media ports
+    ep_cfg.medConfig.clockRate = 48000;
+
+    // in case of trouble check:
+    //      PJSUA_MAX_CALLS
+    //      PJMEDIA_MAX_MTU
+    //      PJ_IOQUEUE_MAX_HANDLES = calls x2
+    //      PJSUA_MAX_PLAYERS = max calls
+
+    ep_cfg.uaConfig.maxCalls = PJSUA_MAX_CALLS;
+
+    auto stun_server = settings.stun_server();
+    if (!stun_server.empty()) {
+        ep_cfg.uaConfig.stunServer.emplace_back(stun_server);
+    }
+
+    ep.libInit(ep_cfg);
+    ep.audDevManager().setNullDev();
+
+    // pjSIP with switch board require matching of SIP audio
+    // and TG audio port clock rate so we MUST force
+    // using 48kHz codecs for all SIP calls
+    std::string codecId = settings.raw_pcm() ? "L16/48000/1" : "opus/48000/2";
+    CodecInfoVector codecVector = ep.codecEnum();
+
+    for (auto const &value : codecVector) {
+        ep.codecSetPriority(value->codecId, (pj_uint8_t) (value->codecId == codecId ? 255 : 0));
+    }
+
+    TransportConfig t_cfg;
+
+    // defaults to any open port
+    t_cfg.port = settings.sip_port();
+    t_cfg.portRange = settings.sip_port_range();
+
+    auto public_address = settings.public_address();
+    if (!public_address.empty()) {
+        t_cfg.publicAddress = public_address;
+    }
+
+    ep.transportCreate(PJSIP_TRANSPORT_UDP, t_cfg);
+
+    ep.libStart();
+}
+
+void Client::start() {
+    account->create(*account_cfg);
+}
+
+std::string Client::user_from_uri(const std::string &uri) {
+    std::string user{};
+
+    pj_pool_t *pj_pool = pjsua_pool_create("temp%p", 2048, 1024);
+
+    if (pj_pool != nullptr) {
+
+        std::vector<char> buffer(uri.begin(), uri.end());
+        buffer.push_back('\0');
+
+        pjsip_uri *pj_uri = pjsip_parse_uri(pj_pool, &buffer[0], uri.size(), PJSIP_PARSE_URI_IN_FROM_TO_HDR);
+
+        if (pj_uri != nullptr && PJSIP_URI_SCHEME_IS_SIP(pj_uri)) {
+            auto pj_sip_uri = static_cast<pjsip_sip_uri *>(pjsip_uri_get_uri(pj_uri));
+            user = std::string(pj_sip_uri->user.ptr,
+                               static_cast<unsigned long>(pj_sip_uri->user.slen));
+        }
+
+        pj_pool_release(pj_pool);
+    }
+
+    return user;
+}
+
+pjsua_call_id Client::Dial(const std::string &uri, const pj::CallOpParam &prm) {
+    auto call = std::make_shared<Call>(*account, logger);
+    set_default_handlers(call);
+
+    // sip ID is known only after making call
+    call->makeCall(uri, prm);
+    auto sip_id = call->getId();
+    calls.emplace(sip_id, call);
+
+    return sip_id;
+}
+
+void Client::set_default_handlers(const std::shared_ptr<Call> &call) {
+    call->addHandler([this, call_wpt = std::weak_ptr<Call>(call)](pj::OnCallStateParam &prm) {
+        if (auto call_spt = call_wpt.lock()) {
+            events.emplace(events::CallStateUpdate{call_spt->getId(), call_spt->getInfo().state});
+        }
+    });
+
+    call->addHandler([this, call_wpt = std::weak_ptr<Call>(call)](pj::OnCallMediaStateParam &prm) {
+        if (auto call_spt = call_wpt.lock()) {
+            events.emplace(events::CallMediaStateUpdate{call_spt->getId(), call_spt->hasMedia()});
+        }
+    });
+}
+
+void Client::Hangup(const pjsua_call_id call_id, const pj::CallOpParam &prm) {
+    auto it = calls.find(call_id);
+    if (it != calls.end()) {
+        auto call = it->second;
+        call->hangup(prm);
+        calls.erase(it);
+    }
+}
+
+void Client::BridgeAudio(const pjsua_call_id call_id, pj::AudioMedia *input, pj::AudioMedia *output) {
+
+    auto it = calls.find(call_id);
+
+    if (it == calls.end()) {
+        throw std::runtime_error{"CALL_NOT_FOUND"};
+    }
+
+    auto sip_audio = it->second->audio_media();
+
+    if (sip_audio == nullptr) {
+        throw std::runtime_error{"SIP_MEDIA_NOT_READY"};
+    }
+
+    sip_audio->startTransmit(*input);
+    output->startTransmit(*sip_audio);
+
+}
+
+void Client::Answer(pjsua_call_id call_id, const pj::CallOpParam &prm) {
+    auto it = calls.find(call_id);
+
+    if (it == calls.end()) {
+        throw std::runtime_error{"CALL_NOT_FOUND"};
+    }
+
+    auto call = it->second;
+    call->answer(prm);
+}
+
+void Client::DialDtmf(pjsua_call_id call_id, const string &dtmf_digits) {
+    auto it = calls.find(call_id);
+
+    if (it == calls.end()) {
+        throw std::runtime_error{"CALL_NOT_FOUND"};
+    }
+
+    auto call = it->second;
+    call->dialDtmf(dtmf_digits);
+}
\ No newline at end of file
diff --git a/tg2sip/sip.h b/tg2sip/sip.h
new file mode 100755
index 0000000..e943e87
--- /dev/null
+++ b/tg2sip/sip.h
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef TG2SIP_SIP_H
+#define TG2SIP_SIP_H
+
+#include <variant>
+#include <pjsua2.hpp>
+#include "logging.h"
+#include "settings.h"
+#include "queue.h"
+#include "utils.h"
+
+namespace sip {
+
+    namespace events {
+        struct IncomingCall {
+            pjsua_call_id id;
+            std::string extension;
+        };
+
+        struct CallStateUpdate {
+            pjsua_call_id id;
+            pjsip_inv_state state;
+        };
+
+        struct CallMediaStateUpdate {
+            pjsua_call_id id;
+            bool has_media;
+        };
+
+        typedef std::variant<IncomingCall, CallStateUpdate, CallMediaStateUpdate> Event;
+    }
+
+    class LogWriter : public pj::LogWriter {
+    public:
+        explicit LogWriter(std::shared_ptr<spdlog::logger> logger) : logger(std::move(logger)) {};
+
+        ~LogWriter() override = default;
+
+        void write(const pj::LogEntry &entry) override;
+
+    private:
+        std::shared_ptr<spdlog::logger> logger;
+    };
+
+    struct AccountConfig : public pj::AccountConfig {
+        explicit AccountConfig(Settings &settings);
+    };
+
+    class Call : public pj::Call {
+    public:
+        Call(pj::Account &acc, std::shared_ptr<spdlog::logger> logger, int call_id);
+
+        ~Call() override;
+
+        void addHandler(std::function<void(pj::OnCallStateParam &)> &&handler);
+
+        void addHandler(std::function<void(pj::OnCallMediaStateParam &)> &&handler);
+
+        const std::string localUser();
+
+        pj::AudioMedia *audio_media();
+
+
+    private:
+        friend class Client;
+
+        void onCallState(pj::OnCallStateParam &prm) override;
+
+        void onCallMediaState(pj::OnCallMediaStateParam &prm) override;
+
+        std::function<void(pj::OnCallStateParam &)> onCallStateHandler;
+        std::function<void(pj::OnCallMediaStateParam &)> onCallMediaStateHandler;
+        std::string local_user_;
+        std::shared_ptr<spdlog::logger> logger;
+    };
+
+    class Account : public pj::Account {
+    public:
+        explicit Account(std::shared_ptr<spdlog::logger> logger) : logger(std::move(logger)) {};
+
+        void addHandler(std::function<void(pj::OnIncomingCallParam &)> &&handler);
+
+    private:
+        void onIncomingCall(pj::OnIncomingCallParam &prm) override;
+
+        std::function<void(pj::OnIncomingCallParam &)> onIncomingCallHandler;
+        std::shared_ptr<spdlog::logger> logger;
+    };
+
+    class Client {
+    public:
+        Client(std::unique_ptr<Account> account_, std::unique_ptr<AccountConfig> account_cfg_,
+               OptionalQueue<events::Event> &events, Settings &settings,
+               std::shared_ptr<spdlog::logger> logger_, LogWriter *sip_log_writer);
+
+        Client(const Client &) = delete;
+
+        Client &operator=(const Client &) = delete;
+
+        virtual ~Client();
+
+        void start();
+
+        pjsua_call_id Dial(const std::string &uri, const pj::CallOpParam &prm);
+
+        void Answer(pjsua_call_id call_id, const pj::CallOpParam &prm);
+
+        void Hangup(pjsua_call_id call_id, const pj::CallOpParam &prm);
+
+        void DialDtmf(pjsua_call_id call_id, const string &dtmf_digits);
+
+        void BridgeAudio(pjsua_call_id call_id, pj::AudioMedia *input, pj::AudioMedia *output);
+
+    private:
+        std::shared_ptr<spdlog::logger> logger;
+
+        std::unique_ptr<Account> account;
+        std::unique_ptr<AccountConfig> account_cfg;
+
+        OptionalQueue<events::Event> &events;
+        std::map<int, std::shared_ptr<Call>> calls;
+
+        static void init_pj_endpoint(Settings &settings, LogWriter *sip_log_writer);
+
+        static std::string user_from_uri(const std::string &uri);
+
+        void set_default_handlers(const std::shared_ptr<Call> &call);
+    };
+}
+
+#endif //TG2SIP_SIP_H
diff --git a/tg2sip/tg.cpp b/tg2sip/tg.cpp
new file mode 100755
index 0000000..806c12e
--- /dev/null
+++ b/tg2sip/tg.cpp
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "tg.h"
+#include "queue.h"
+
+using namespace tg;
+
+Client::Client(Settings &settings, std::shared_ptr<spdlog::logger> logger_,
+                   OptionalQueue<Object> &events_)
+        : logger(std::move(logger_)), events(events_) {
+
+    client = std::make_unique<td::Client>();
+    init_lib_parameters(settings);
+    init_proxy(settings);
+}
+
+Client::~Client() {
+    TRACE(logger, "~Client");
+    is_closed = true;
+    if (thread_.joinable()) {
+        thread_.join();
+    }
+    client.release();
+    TRACE(logger, "~Client done");
+}
+
+void Client::init_lib_parameters(Settings &settings) {
+    lib_parameters = td_api::make_object<td_api::tdlibParameters>();
+
+    lib_parameters->api_id_ = settings.api_id();
+    lib_parameters->api_hash_ = settings.api_hash();
+    lib_parameters->database_directory_ = settings.db_folder();
+
+    lib_parameters->system_language_code_ = settings.sys_lang_code();
+    lib_parameters->device_model_ = settings.device_model();
+    lib_parameters->system_version_ = settings.system_version();
+    lib_parameters->application_version_ = settings.app_version();
+
+    lib_parameters->use_file_database_ = false;
+    lib_parameters->use_chat_info_database_ = true;
+    lib_parameters->use_message_database_ = false;
+    lib_parameters->use_secret_chats_ = false;
+    lib_parameters->enable_storage_optimizer_ = true;
+}
+
+void Client::init_proxy(Settings &settings) {
+    if (settings.proxy_enabled()) {
+        auto socks_proxy = td_api::make_object<td_api::proxySocks5>(
+                settings.proxy_address(),
+                settings.proxy_port(),
+                settings.proxy_username(),
+                settings.proxy_password()
+        );
+        proxy = td_api::move_object_as<td_api::Proxy>(socks_proxy);
+    } else {
+        auto empty_proxy = td_api::make_object<td_api::proxyEmpty>();
+        proxy = td_api::move_object_as<td_api::Proxy>(empty_proxy);
+    }
+}
+
+void Client::loop() {
+    TRACE(logger, "TG client thread started");
+
+    while (!is_closed) {
+        auto response = client->receive(WAIT_TIMEOUT);
+        process_response(std::move(response));
+    }
+    TRACE(logger, "TG client thread ended");
+}
+
+void Client::start() {
+    thread_ = std::thread(&Client::loop, this);
+    pthread_setname_np(thread_.native_handle(), "tg_client");
+}
+
+void Client::process_response(td::Client::Response response) {
+
+    if (!response.object) {
+        return;
+    }
+
+    TRACE(logger, "TG client got response with ID {}\n{}", response.id, to_string(response.object));
+
+    if (response.id == 0) {
+        return process_update(std::move(response.object));
+    }
+
+    auto it = handlers.find(response.id);
+    if (it != handlers.end()) {
+        it->second(std::move(response.object));
+        handlers.erase(it->first);
+    }
+}
+
+void Client::process_update(Object update) {
+    switch (update->get_id()) {
+        case td_api::updateAuthorizationState::ID: {
+            auto update_authorization_state = td_api::move_object_as<td_api::updateAuthorizationState>(update);
+            on_authorization_state_update(std::move(update_authorization_state->authorization_state_));
+            break;
+        }
+        case td_api::updateConnectionState::ID: {
+            auto update_connection_state = td_api::move_object_as<td_api::updateConnectionState>(update);
+            if (update_connection_state->state_->get_id() == td_api::connectionStateReady::ID) {
+                logger->info("TG client connected");
+            }
+            break;
+        }
+        case td_api::updateCall::ID:
+        case td_api::updateNewMessage::ID: {
+            events.emplace(std::move(update));
+            break;
+        }
+        default:
+            break;
+    }
+}
+
+void Client::send_query(td_api::object_ptr<td_api::Function> f, std::function<void(Object)> handler) {
+    auto query_id = next_query_id();
+    if (handler) {
+        handlers.emplace(query_id, std::move(handler));
+    }
+    client->send({query_id, std::move(f)});
+}
+
+std::future<Client::Object> Client::send_query_async(td_api::object_ptr<td_api::Function> f) {
+
+    if (std::this_thread::get_id() == thread_.get_id()) {
+        logger->critical("Call of send_query_async from TG thread will cause deadlock");
+        throw;
+    }
+
+    auto promise = std::make_shared<std::promise<Object>>();
+    auto future = promise->get_future();
+
+    send_query(std::move(f), [this, promise](Object object) {
+        try {
+            promise->set_value(std::move(object));
+        } catch (std::future_error &error) {
+            logger->critical("failed to set send_query_async promise value {}", error.code());
+        }
+    });
+
+    return future;
+}
+
+std::uint64_t Client::next_query_id() {
+    return ++current_query_id;
+}
+
+auto Client::create_authentication_query_handler() {
+    return [this](Object object) {
+        check_authentication_error(std::move(object));
+    };
+}
+
+void Client::check_authentication_error(Object object) {
+    if (object->get_id() == td_api::error::ID) {
+        auto error = td_api::move_object_as<td_api::error>(object);
+        logger->error("TG client authorization error\n{}", to_string(error));
+    }
+}
+
+void Client::on_authorization_state_update(td_api::object_ptr<td_api::AuthorizationState> authorization_state) {
+    switch (authorization_state->get_id()) {
+        case td_api::authorizationStateReady::ID:
+            is_ready_.set_value(true);
+            logger->info("TG client authorization ready");
+            break;
+        case td_api::authorizationStateWaitEncryptionKey::ID:
+            send_query(td_api::make_object<td_api::checkDatabaseEncryptionKey>(),
+                       create_authentication_query_handler());
+            send_query(td_api::make_object<td_api::setProxy>(td_api::move_object_as<td_api::Proxy>(proxy)),
+                       create_authentication_query_handler());
+            break;
+        case td_api::authorizationStateWaitTdlibParameters::ID: {
+            send_query(td_api::make_object<td_api::setTdlibParameters>(
+                    std::move(lib_parameters)), create_authentication_query_handler());
+            break;
+        }
+        default:
+            is_ready_.set_value(false);
+            logger->error("TG client auto sign-on failed");
+            break;
+    }
+}
diff --git a/tg2sip/tg.h b/tg2sip/tg.h
new file mode 100755
index 0000000..484d86b
--- /dev/null
+++ b/tg2sip/tg.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef TG2SIP_TG_H
+#define TG2SIP_TG_H
+
+#include <thread>
+#include <functional>
+#include <future>
+#include <map>
+#include <td/telegram/Client.h>
+#include "utils.h"
+#include "logging.h"
+#include "settings.h"
+#include "queue.h"
+
+namespace tg {
+
+    namespace td_api = td::td_api;
+
+    class Client {
+    public:
+        using Object = td_api::object_ptr<td_api::Object>;
+
+        virtual ~Client();
+
+        explicit Client(Settings &settings, std::shared_ptr<spdlog::logger> logger_,
+                          OptionalQueue<Object> &events_);
+
+        void start();
+
+        void send_query(td_api::object_ptr<td_api::Function> f, std::function<void(Object)> handler = nullptr);
+
+        std::future<Object> send_query_async(td_api::object_ptr<td_api::Function> f);
+
+        std::future<bool> is_ready() { return is_ready_.get_future(); };
+
+    private:
+
+        std::shared_ptr<spdlog::logger> logger;
+        OptionalQueue<Object> &events;
+
+        const double WAIT_TIMEOUT = 10;
+
+        std::unique_ptr<td::Client> client;
+        std::unique_ptr<td_api::tdlibParameters> lib_parameters;
+        td_api::object_ptr<td_api::Proxy> proxy;
+
+        std::thread thread_;
+
+        std::promise<bool> is_ready_;
+        bool is_closed{false};
+        std::uint64_t current_query_id{0};
+
+        std::map<std::uint64_t, std::function<void(Object)>> handlers;
+
+        void init_lib_parameters(Settings &settings);
+
+        void init_proxy(Settings &settings);
+
+        void loop();
+
+        void process_response(td::Client::Response response);
+
+        void process_update(Object update);
+
+        std::uint64_t next_query_id();
+
+        auto create_authentication_query_handler();
+
+        void check_authentication_error(Object object);
+
+        void on_authorization_state_update(td_api::object_ptr<td_api::AuthorizationState> authorization_state);
+    };
+}
+
+#endif //TG2SIP_TG_H
diff --git a/tg2sip/utils.cpp b/tg2sip/utils.cpp
new file mode 100644
index 0000000..c8da02b
--- /dev/null
+++ b/tg2sip/utils.cpp
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <algorithm>
+#include "utils.h"
+
+bool is_digits(const std::string &str) { return std::all_of(str.begin(), str.end(), ::isdigit); };
\ No newline at end of file
diff --git a/tg2sip/utils.h b/tg2sip/utils.h
new file mode 100755
index 0000000..cfcf211
--- /dev/null
+++ b/tg2sip/utils.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2017-2018 infactum (infactum@gmail.com)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef TG2SIP_UTILS_H
+#define TG2SIP_UTILS_H
+
+#include <memory>
+
+bool is_digits(const std::string &str);
+
+template<class ToT, class FromT>
+std::unique_ptr<ToT> move_unique_ptr_as(std::unique_ptr<FromT> &from) {
+    return std::unique_ptr<ToT>(static_cast<ToT *>(from.release()));
+}
+
+#endif //TG2SIP_UTILS_H