28 files changed, 803 insertions, 2860 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5655cd8..417efab 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,6 +1,8 @@
 cmake_minimum_required(VERSION 3.8)
 project(AltCraft)
 set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
 include(externalProject)
 
@@ -26,7 +28,7 @@ add_definitions(${LOGGER_DEFINITIONS})
 
 #Set compiler's flags and setup platfrom-dependent libraries
 if (CMAKE_COMPILER_IS_GNUCXX)
-    #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Wextra -Werror")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -pedantic -Wextra -Werror")
     #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0")
     #set(CMAKE_CXX_FLAGS  "${CMAKE_CXX_FLAGS} -O3")
     #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address")
@@ -34,6 +36,11 @@ if (CMAKE_COMPILER_IS_GNUCXX)
     #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -p")
     set(PLATFORM_LIBRARIES "pthread" "stdc++fs")
 endif ()
+
+if(MSVC)
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /std:c++17")
+endif(MSVC)
+
 target_link_libraries(AltCraft ${PLATFORM_LIBRARIES})
 
 ############
@@ -45,29 +52,28 @@ add_subdirectory(depedencies)
 target_include_directories(AltCraft PUBLIC ./depedencies/include)
 target_link_libraries(AltCraft deps)
 
-#Setup SFML
-set (SFML_ROOT "${CMAKE_SOURCE_DIR}/external/SFML")
-find_package(SFML 2.3 COMPONENTS system window graphics network REQUIRED)
-if (SFML_FOUND)
-    target_link_libraries(AltCraft ${SFML_LIBRARIES})
-    target_include_directories(AltCraft PUBLIC ${SFML_INCLUDE_DIR})
-else ()
-    message(FATAL_ERROR "SFML not found!")
-endif ()
+#Setup SDL2
+find_package(SDL2 REQUIRED)
+target_link_libraries(AltCraft ${SDL2_LIBRARY})
+target_include_directories(AltCraft PUBLIC ${SDL2_INCLUDE_DIR})
+
+#Setup SDL2_net
+find_package(SDL2_net REQUIRED)
+target_link_libraries(AltCraft ${SDL2_NET_LIBRARIES})
+target_include_directories(AltCraft PUBLIC ${SDL2_NET_INCLUDE_DIRS})
 
 #Setup SFML
-#add_subdirectory(external/SFML)
-#target_include_directories(AltCraft PUBLIC external/SFML/include)
-#target_link_libraries(AltCraft sfml-main sfml-system sfml-network sfml-window sfml-graphics)
+set (SFML_ROOT "c:/dev/vcpkg/installed/x86-windows/")
+find_package(SFML 2.3 COMPONENTS system window graphics network REQUIRED)
+target_link_libraries(AltCraft ${SFML_LIBRARIES})
+target_include_directories(AltCraft PUBLIC ${SFML_INCLUDE_DIR})
 
 #Setup OpenGL
 find_package(OpenGL REQUIRED)
-if (OPENGL_FOUND)
-    target_link_libraries(AltCraft ${OPENGL_LIBRARIES})
-    target_include_directories(AltCraft PUBLIC ${OPENGL_INCLUDE_DIRS})
-else ()
-    message(FATAL_ERROR "OpenGL not found!")
-endif ()
+target_link_libraries(AltCraft ${OPENGL_LIBRARIES})
+target_include_directories(AltCraft PUBLIC ${OPENGL_INCLUDE_DIRS})
+
+
 
 #################
 # COPY RESOURCES
diff --git a/cmake/FindSDL2_net.cmake b/cmake/FindSDL2_net.cmake
new file mode 100644
index 0000000..2ad6b9b
--- /dev/null
+++ b/cmake/FindSDL2_net.cmake
@@ -0,0 +1,88 @@
+# - Locate SDL2_net library
+# This module defines:
+#  SDL2_NET_LIBRARIES, the name of the library to link against
+#  SDL2_NET_INCLUDE_DIRS, where to find the headers
+#  SDL2_NET_FOUND, if false, do not try to link against
+#  SDL2_NET_VERSION_STRING - human-readable string containing the version of SDL2_net
+#
+# For backward compatiblity the following variables are also set:
+#  SDLNET_LIBRARY (same value as SDL2_NET_LIBRARIES)
+#  SDLNET_INCLUDE_DIR (same value as SDL2_NET_INCLUDE_DIRS)
+#  SDLNET_FOUND (same value as SDL2_NET_FOUND)
+#
+# $SDLDIR is an environment variable that would
+# correspond to the ./configure --prefix=$SDLDIR
+# used in building SDL.
+#
+# Created by Eric Wing. This was influenced by the FindSDL.cmake
+# module, but with modifications to recognize OS X frameworks and
+# additional Unix paths (FreeBSD, etc).
+
+#=============================================================================
+# Copyright 2005-2009 Kitware, Inc.
+# Copyright 2012 Benjamin Eikel
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+if(NOT SDL2_NET_INCLUDE_DIR AND SDLNET_INCLUDE_DIR)
+  set(SDL2_NET_INCLUDE_DIR ${SDLNET_INCLUDE_DIR} CACHE PATH "directory cache
+entry initialized from old variable name")
+endif()
+find_path(SDL2_NET_INCLUDE_DIR SDL_net.h
+  HINTS
+    ENV SDLNETDIR
+    ENV SDLDIR
+  PATH_SUFFIXES include/SDL2 include/SDL2.0 include
+)
+
+if(NOT SDL2_NET_LIBRARY AND SDLNET_LIBRARY)
+  set(SDL2_NET_LIBRARY ${SDLNET_LIBRARY} CACHE FILEPATH "file cache entry
+initialized from old variable name")
+endif()
+find_library(SDL2_NET_LIBRARY
+  NAMES SDL2_net
+  HINTS
+    ENV SDLNETDIR
+    ENV SDLDIR
+  PATH_SUFFIXES lib
+)
+
+if(SDL2_NET_INCLUDE_DIR AND EXISTS "${SDL2_NET_INCLUDE_DIR}/SDL2_net.h")
+  file(STRINGS "${SDL2_NET_INCLUDE_DIR}/SDL2_net.h" SDL2_NET_VERSION_MAJOR_LINE REGEX "^#define[ \t]+SDL2_NET_MAJOR_VERSION[ \t]+[0-9]+$")
+  file(STRINGS "${SDL2_NET_INCLUDE_DIR}/SDL2_net.h" SDL2_NET_VERSION_MINOR_LINE REGEX "^#define[ \t]+SDL2_NET_MINOR_VERSION[ \t]+[0-9]+$")
+  file(STRINGS "${SDL2_NET_INCLUDE_DIR}/SDL2_net.h" SDL2_NET_VERSION_PATCH_LINE REGEX "^#define[ \t]+SDL2_NET_PATCHLEVEL[ \t]+[0-9]+$")
+  string(REGEX REPLACE "^#define[ \t]+SDL2_NET_MAJOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_NET_VERSION_MAJOR "${SDL2_NET_VERSION_MAJOR_LINE}")
+  string(REGEX REPLACE "^#define[ \t]+SDL2_NET_MINOR_VERSION[ \t]+([0-9]+)$" "\\1" SDL2_NET_VERSION_MINOR "${SDL2_NET_VERSION_MINOR_LINE}")
+  string(REGEX REPLACE "^#define[ \t]+SDL2_NET_PATCHLEVEL[ \t]+([0-9]+)$" "\\1" SDL2_NET_VERSION_PATCH "${SDL2_NET_VERSION_PATCH_LINE}")
+  set(SDL2_NET_VERSION_STRING ${SDL2_NET_VERSION_MAJOR}.${SDL2_NET_VERSION_MINOR}.${SDL2_NET_VERSION_PATCH})
+  unset(SDL2_NET_VERSION_MAJOR_LINE)
+  unset(SDL2_NET_VERSION_MINOR_LINE)
+  unset(SDL2_NET_VERSION_PATCH_LINE)
+  unset(SDL2_NET_VERSION_MAJOR)
+  unset(SDL2_NET_VERSION_MINOR)
+  unset(SDL2_NET_VERSION_PATCH)
+endif()
+
+set(SDL2_NET_LIBRARIES ${SDL2_NET_LIBRARY})
+set(SDL2_NET_INCLUDE_DIRS ${SDL2_NET_INCLUDE_DIR})
+
+include(FindPackageHandleStandardArgs)
+
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(SDL2_net
+                                  REQUIRED_VARS SDL2_NET_LIBRARIES SDL2_NET_INCLUDE_DIRS
+                                  VERSION_VAR SDL2_NET_VERSION_STRING)
+
+# for backward compatiblity
+set(SDLNET_LIBRARY ${SDL2_NET_LIBRARIES})
+set(SDLNET_INCLUDE_DIR ${SDL2_NET_INCLUDE_DIRS})
+set(SDLNET_FOUND ${SDL2_NET_FOUND})
+
+mark_as_advanced(SDL2_NET_LIBRARY SDL2_NET_INCLUDE_DIR)
\ No newline at end of file
diff --git a/cwd/shaders/gui.fs b/cwd/shaders/gui.fs
new file mode 100644
index 0000000..95196b9
--- /dev/null
+++ b/cwd/shaders/gui.fs
@@ -0,0 +1,21 @@
+#version 330 core
+
+in vec2 uv;
+
+uniform vec4 widgetTexture;
+uniform sampler2D textureAtlas;
+
+vec2 TransformTextureCoord(vec4 TextureAtlasCoords, vec2 UvCoords) {
+    float x = TextureAtlasCoords.x;
+    float y = TextureAtlasCoords.y;
+    float w = TextureAtlasCoords.z;
+    float h = TextureAtlasCoords.w;
+    vec2 A = vec2(x, 1 - y - h);
+    vec2 B = vec2(x + w, 1 - y);
+    return A + UvCoords * (B - A);
+}
+
+void main(){
+    vec4 color = texture(textureAtlas,TransformTextureCoord(widgetTexture,uv));
+    gl_FragColor = color;
+}
\ No newline at end of file
diff --git a/cwd/shaders/gui.vs b/cwd/shaders/gui.vs
new file mode 100644
index 0000000..b6f848b
--- /dev/null
+++ b/cwd/shaders/gui.vs
@@ -0,0 +1,27 @@
+#version 330 core
+
+uniform vec4 transform;
+
+layout (location = 0) in vec3 position;
+layout (location = 1) in vec2 UvCoordinates;
+
+out vec2 uv;
+
+vec2 TransfromWidgetCoord() {
+    vec2 origin = vec2((transform.x * 2.0f) - 1.0f, (0.5 - transform.y) * 2.0f);
+
+    float x = transform.x;
+    float y = transform.y;
+    float w = transform.z;
+    float h = transform.w;
+    vec2 A = vec2(x, 1 - y - h);
+    vec2 B = vec2(x + w, 1 - y);
+    vec2 ret = vec2(A + position.xy * (B - A));
+    return vec2(ret.x-1.0f,ret.y);
+}
+
+void main(){
+    uv = UvCoordinates;
+
+    gl_Position = vec4(TransfromWidgetCoord(),0,1);
+}
\ No newline at end of file
diff --git a/depedencies/include/mpark/config.hpp b/depedencies/include/mpark/config.hpp
deleted file mode 100644
index b5706b2..0000000
--- a/depedencies/include/mpark/config.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_CONFIG_HPP
-#define MPARK_CONFIG_HPP
-
-// MSVC 2015 Update 3.
-#if __cplusplus < 201103L && (!defined(_MSC_VER) || _MSC_FULL_VER < 190024215)
-#error "MPark.Variant requires C++11 support."
-#endif
-
-#ifndef __has_builtin
-#define __has_builtin(x) 0
-#endif
-
-#ifndef __has_include
-#define __has_include(x) 0
-#endif
-
-#ifndef __has_feature
-#define __has_feature(x) 0
-#endif
-
-#if __has_builtin(__builtin_addressof) || \
-    (defined(__GNUC__) && __GNUC__ >= 7) || defined(_MSC_VER)
-#define MPARK_BUILTIN_ADDRESSOF
-#endif
-
-#if __has_builtin(__type_pack_element)
-#define MPARK_TYPE_PACK_ELEMENT
-#endif
-
-#if defined(__cpp_constexpr) && __cpp_constexpr >= 201304
-#define MPARK_CPP14_CONSTEXPR
-#endif
-
-#if __has_feature(cxx_exceptions) || defined(__cpp_exceptions)
-#define MPARK_EXCEPTIONS
-#endif
-
-#if defined(__cpp_generic_lambdas) || defined(_MSC_VER)
-#define MPARK_GENERIC_LAMBDAS
-#endif
-
-#if defined(__cpp_lib_integer_sequence)
-#define MPARK_INTEGER_SEQUENCE
-#endif
-
-#if defined(__cpp_return_type_deduction) || defined(_MSC_VER)
-#define MPARK_RETURN_TYPE_DEDUCTION
-#endif
-
-#if defined(__cpp_lib_transparent_operators) || defined(_MSC_VER)
-#define MPARK_TRANSPARENT_OPERATORS
-#endif
-
-#if defined(__cpp_variable_templates) || defined(_MSC_VER)
-#define MPARK_VARIABLE_TEMPLATES
-#endif
-
-#if !defined(__GLIBCXX__) || __has_include(<codecvt>)  // >= libstdc++-5
-#define MPARK_TRIVIALITY_TYPE_TRAITS
-#endif
-
-#endif  // MPARK_CONFIG_HPP
diff --git a/depedencies/include/mpark/in_place.hpp b/depedencies/include/mpark/in_place.hpp
deleted file mode 100644
index 56cae13..0000000
--- a/depedencies/include/mpark/in_place.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_IN_PLACE_HPP
-#define MPARK_IN_PLACE_HPP
-
-#include <cstddef>
-
-#include "config.hpp"
-
-namespace mpark {
-
-  struct in_place_t { explicit in_place_t() = default; };
-
-  template <std::size_t I>
-  struct in_place_index_t { explicit in_place_index_t() = default; };
-
-  template <typename T>
-  struct in_place_type_t { explicit in_place_type_t() = default; };
-
-#ifdef MPARK_VARIABLE_TEMPLATES
-  constexpr in_place_t in_place{};
-
-  template <std::size_t I> constexpr in_place_index_t<I> in_place_index{};
-
-  template <typename T> constexpr in_place_type_t<T> in_place_type{};
-#endif
-
-}  // namespace mpark
-
-#endif  // MPARK_IN_PLACE_HPP
diff --git a/depedencies/include/mpark/lib.hpp b/depedencies/include/mpark/lib.hpp
deleted file mode 100644
index bba58d8..0000000
--- a/depedencies/include/mpark/lib.hpp
+++ /dev/null
@@ -1,453 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_LIB_HPP
-#define MPARK_LIB_HPP
-
-#include <memory>
-#include <functional>
-#include <type_traits>
-#include <utility>
-
-#include "config.hpp"
-
-#define RETURN(...)                                          \
-  noexcept(noexcept(__VA_ARGS__)) -> decltype(__VA_ARGS__) { \
-    return __VA_ARGS__;                                      \
-  }
-
-namespace mpark {
-  namespace lib {
-    template <typename T>
-    struct identity { using type = T; };
-
-    inline namespace cpp14 {
-      template <typename T, std::size_t N>
-      struct array {
-        constexpr const T &operator[](std::size_t index) const {
-          return data[index];
-        }
-
-        T data[N == 0 ? 1 : N];
-      };
-
-      template <typename T>
-      using add_pointer_t = typename std::add_pointer<T>::type;
-
-      template <typename... Ts>
-      using common_type_t = typename std::common_type<Ts...>::type;
-
-      template <typename T>
-      using decay_t = typename std::decay<T>::type;
-
-      template <bool B, typename T = void>
-      using enable_if_t = typename std::enable_if<B, T>::type;
-
-      template <typename T>
-      using remove_const_t = typename std::remove_const<T>::type;
-
-      template <typename T>
-      using remove_reference_t = typename std::remove_reference<T>::type;
-
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &t) noexcept {
-        return static_cast<T &&>(t);
-      }
-
-      template <typename T>
-      inline constexpr T &&forward(remove_reference_t<T> &&t) noexcept {
-        static_assert(!std::is_lvalue_reference<T>::value,
-                      "can not forward an rvalue as an lvalue");
-        return static_cast<T &&>(t);
-      }
-
-      template <typename T>
-      inline constexpr remove_reference_t<T> &&move(T &&t) noexcept {
-        return static_cast<remove_reference_t<T> &&>(t);
-      }
-
-#ifdef MPARK_INTEGER_SEQUENCE
-      template <typename T, T... Is>
-      using integer_sequence = std::integer_sequence<T, Is...>;
-
-      template <std::size_t... Is>
-      using index_sequence = std::index_sequence<Is...>;
-
-      template <std::size_t N>
-      using make_index_sequence = std::make_index_sequence<N>;
-
-      template <typename... Ts>
-      using index_sequence_for = std::index_sequence_for<Ts...>;
-#else
-      template <typename T, T... Is>
-      struct integer_sequence {
-        using value_type = T;
-        static constexpr std::size_t size() noexcept { return sizeof...(Is); }
-      };
-
-      template <std::size_t... Is>
-      using index_sequence = integer_sequence<std::size_t, Is...>;
-
-      template <typename Lhs, typename Rhs>
-      struct make_index_sequence_concat;
-
-      template <std::size_t... Lhs, std::size_t... Rhs>
-      struct make_index_sequence_concat<index_sequence<Lhs...>,
-                                        index_sequence<Rhs...>>
-          : identity<index_sequence<Lhs..., (sizeof...(Lhs) + Rhs)...>> {};
-
-      template <std::size_t N>
-      struct make_index_sequence_impl;
-
-      template <std::size_t N>
-      using make_index_sequence = typename make_index_sequence_impl<N>::type;
-
-      template <std::size_t N>
-      struct make_index_sequence_impl
-          : make_index_sequence_concat<make_index_sequence<N / 2>,
-                                       make_index_sequence<N - (N / 2)>> {};
-
-      template <>
-      struct make_index_sequence_impl<0> : identity<index_sequence<>> {};
-
-      template <>
-      struct make_index_sequence_impl<1> : identity<index_sequence<0>> {};
-
-      template <typename... Ts>
-      using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
-#endif
-
-      // <functional>
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using equal_to = std::equal_to<>;
-#else
-      struct equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) == lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using not_equal_to = std::not_equal_to<>;
-#else
-      struct not_equal_to {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) != lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using less = std::less<>;
-#else
-      struct less {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) < lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater = std::greater<>;
-#else
-      struct greater {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) > lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using less_equal = std::less_equal<>;
-#else
-      struct less_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) <= lib::forward<Rhs>(rhs))
-      };
-#endif
-
-#ifdef MPARK_TRANSPARENT_OPERATORS
-      using greater_equal = std::greater_equal<>;
-#else
-      struct greater_equal {
-        template <typename Lhs, typename Rhs>
-        inline constexpr auto operator()(Lhs &&lhs, Rhs &&rhs) const
-          RETURN(lib::forward<Lhs>(lhs) >= lib::forward<Rhs>(rhs))
-      };
-#endif
-    }  // namespace cpp14
-
-    inline namespace cpp17 {
-
-      // <type_traits>
-      template <bool B>
-      using bool_constant = std::integral_constant<bool, B>;
-
-      template <typename...>
-      struct voider : identity<void> {};
-
-      template <typename... Ts>
-      using void_t = typename voider<Ts...>::type;
-
-      namespace detail {
-        namespace swappable {
-
-          using std::swap;
-
-          template <typename T>
-          struct is_swappable_impl {
-            private:
-            template <typename U,
-                      typename = decltype(swap(std::declval<U &>(),
-                                               std::declval<U &>()))>
-            inline static std::true_type test(int);
-
-            template <typename U>
-            inline static std::false_type test(...);
-
-            public:
-            using type = decltype(test<T>(0));
-          };
-
-          template <typename T>
-          using is_swappable = typename is_swappable_impl<T>::type;
-
-          template <typename T, bool = is_swappable<T>::value>
-          struct is_nothrow_swappable {
-            static constexpr bool value =
-                noexcept(swap(std::declval<T &>(), std::declval<T &>()));
-          };
-
-          template <typename T>
-          struct is_nothrow_swappable<T, false> : std::false_type {};
-
-        }  // namespace swappable
-      }  // namespace detail
-
-      template <typename T>
-      using is_swappable = detail::swappable::is_swappable<T>;
-
-      template <typename T>
-      using is_nothrow_swappable = detail::swappable::is_nothrow_swappable<T>;
-
-      // <functional>
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-      template <typename F, typename... As>
-      inline constexpr auto invoke(F &&f, As &&... as)
-          RETURN(lib::forward<F>(f)(lib::forward<As>(as)...))
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-      template <typename B, typename T, typename D>
-      inline constexpr auto invoke(T B::*pmv, D &&d)
-          RETURN(lib::forward<D>(d).*pmv)
-
-      template <typename Pmv, typename Ptr>
-      inline constexpr auto invoke(Pmv pmv, Ptr &&ptr)
-          RETURN((*lib::forward<Ptr>(ptr)).*pmv)
-
-      template <typename B, typename T, typename D, typename... As>
-      inline constexpr auto invoke(T B::*pmf, D &&d, As &&... as)
-          RETURN((lib::forward<D>(d).*pmf)(lib::forward<As>(as)...))
-
-      template <typename Pmf, typename Ptr, typename... As>
-      inline constexpr auto invoke(Pmf pmf, Ptr &&ptr, As &&... as)
-          RETURN(((*lib::forward<Ptr>(ptr)).*pmf)(lib::forward<As>(as)...))
-
-      namespace detail {
-
-        template <typename Void, typename, typename...>
-        struct invoke_result {};
-
-        template <typename F, typename... Args>
-        struct invoke_result<void_t<decltype(lib::invoke(
-                                 std::declval<F>(), std::declval<Args>()...))>,
-                             F,
-                             Args...>
-            : identity<decltype(
-                  lib::invoke(std::declval<F>(), std::declval<Args>()...))> {};
-
-      }  // namespace detail
-
-      template <typename F, typename... Args>
-      using invoke_result = detail::invoke_result<void, F, Args...>;
-
-      template <typename F, typename... Args>
-      using invoke_result_t = typename invoke_result<F, Args...>::type;
-
-      namespace detail {
-
-        template <typename Void, typename, typename...>
-        struct is_invocable : std::false_type {};
-
-        template <typename F, typename... Args>
-        struct is_invocable<void_t<invoke_result_t<F, Args...>>, F, Args...>
-            : std::true_type {};
-
-        template <typename Void, typename, typename, typename...>
-        struct is_invocable_r : std::false_type {};
-
-        template <typename R, typename F, typename... Args>
-        struct is_invocable_r<void_t<invoke_result_t<F, Args...>>,
-                              R,
-                              F,
-                              Args...>
-            : std::is_convertible<invoke_result_t<F, Args...>, R> {};
-
-      }  // namespace detail
-
-      template <typename F, typename... Args>
-      using is_invocable = detail::is_invocable<void, F, Args...>;
-
-      template <typename R, typename F, typename... Args>
-      using is_invocable_r = detail::is_invocable_r<void, R, F, Args...>;
-
-      // <memory>
-#ifdef MPARK_BUILTIN_ADDRESSOF
-      template <typename T>
-      inline constexpr T *addressof(T &arg) {
-        return __builtin_addressof(arg);
-      }
-#else
-      namespace detail {
-
-        namespace has_addressof_impl {
-
-          struct fail;
-
-          template <typename T>
-          inline fail operator&(T &&);
-
-          template <typename T>
-          inline static constexpr bool impl() {
-            return (std::is_class<T>::value || std::is_union<T>::value) &&
-                   !std::is_same<decltype(&std::declval<T &>()), fail>::value;
-          }
-
-        }  // namespace has_addressof_impl
-
-        template <typename T>
-        using has_addressof = bool_constant<has_addressof_impl::impl<T>()>;
-
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::true_type) {
-          return std::addressof(arg);
-        }
-
-        template <typename T>
-        inline constexpr T *addressof(T &arg, std::false_type) {
-          return &arg;
-        }
-
-      }  // namespace detail
-
-      template <typename T>
-      inline constexpr T *addressof(T &arg) {
-        return detail::addressof(arg, detail::has_addressof<T>{});
-      }
-#endif
-
-      template <typename T>
-      inline constexpr T *addressof(const T &&) = delete;
-
-    }  // namespace cpp17
-
-    template <typename T>
-    struct remove_all_extents : identity<T> {};
-
-    template <typename T, std::size_t N>
-    struct remove_all_extents<array<T, N>> : remove_all_extents<T> {};
-
-    template <typename T>
-    using remove_all_extents_t = typename remove_all_extents<T>::type;
-
-    template <std::size_t N>
-    using size_constant = std::integral_constant<std::size_t, N>;
-
-    template <bool... Bs>
-    using bool_sequence = integer_sequence<bool, Bs...>;
-
-    template <std::size_t I, typename T>
-    struct indexed_type : size_constant<I>, identity<T> {};
-
-    template <bool... Bs>
-    using all =
-        std::is_same<bool_sequence<true, Bs...>, bool_sequence<Bs..., true>>;
-
-#ifdef MPARK_TYPE_PACK_ELEMENT
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = __type_pack_element<I, Ts...>;
-#else
-    template <std::size_t I, typename... Ts>
-    struct type_pack_element_impl {
-      private:
-      template <typename>
-      struct set;
-
-      template <std::size_t... Is>
-      struct set<index_sequence<Is...>> : indexed_type<Is, Ts>... {};
-
-      template <typename T>
-      inline static std::enable_if<true, T> impl(indexed_type<I, T>);
-
-      inline static std::enable_if<false> impl(...);
-
-      public:
-      using type = decltype(impl(set<index_sequence_for<Ts...>>{}));
-    };
-
-    template <std::size_t I, typename... Ts>
-    using type_pack_element = typename type_pack_element_impl<I, Ts...>::type;
-
-    template <std::size_t I, typename... Ts>
-    using type_pack_element_t = typename type_pack_element<I, Ts...>::type;
-#endif
-
-#ifdef MPARK_TRIVIALITY_TYPE_TRAITS
-    template <typename T>
-    using is_trivially_copy_constructible =
-        std::is_trivially_copy_constructible<T>;
-
-    template <typename T>
-    using is_trivially_move_constructible =
-        std::is_trivially_move_constructible<T>;
-
-    template <typename T>
-    using is_trivially_copy_assignable = std::is_trivially_copy_assignable<T>;
-
-    template <typename T>
-    using is_trivially_move_assignable = std::is_trivially_move_assignable<T>;
-#else
-    template <typename T>
-    struct is_trivially_copy_constructible
-        : bool_constant<
-              std::is_copy_constructible<T>::value && __has_trivial_copy(T)> {};
-
-    template <typename T>
-    struct is_trivially_move_constructible : bool_constant<__is_trivial(T)> {};
-
-    template <typename T>
-    struct is_trivially_copy_assignable
-        : bool_constant<
-              std::is_copy_assignable<T>::value && __has_trivial_assign(T)> {};
-
-    template <typename T>
-    struct is_trivially_move_assignable : bool_constant<__is_trivial(T)> {};
-#endif
-
-  }  // namespace lib
-}  // namespace mpark
-
-#undef RETURN
-
-#endif  // MPARK_LIB_HPP
diff --git a/depedencies/include/mpark/variant.hpp b/depedencies/include/mpark/variant.hpp
deleted file mode 100644
index 3faecba..0000000
--- a/depedencies/include/mpark/variant.hpp
+++ /dev/null
@@ -1,1827 +0,0 @@
-// MPark.Variant
-//
-// Copyright Michael Park, 2015-2017
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
-
-#ifndef MPARK_VARIANT_HPP
-#define MPARK_VARIANT_HPP
-
-/*
-   variant synopsis
-
-namespace std {
-
-  // 20.7.2, class template variant
-  template <class... Types>
-  class variant {
-  public:
-
-    // 20.7.2.1, constructors
-    constexpr variant() noexcept(see below);
-    variant(const variant&);
-    variant(variant&&) noexcept(see below);
-
-    template <class T> constexpr variant(T&&) noexcept(see below);
-
-    template <class T, class... Args>
-    constexpr explicit variant(in_place_type_t<T>, Args&&...);
-
-    template <class T, class U, class... Args>
-    constexpr explicit variant(
-        in_place_type_t<T>, initializer_list<U>, Args&&...);
-
-    template <size_t I, class... Args>
-    constexpr explicit variant(in_place_index_t<I>, Args&&...);
-
-    template <size_t I, class U, class... Args>
-    constexpr explicit variant(
-        in_place_index_t<I>, initializer_list<U>, Args&&...);
-
-    // 20.7.2.2, destructor
-    ~variant();
-
-    // 20.7.2.3, assignment
-    variant& operator=(const variant&);
-    variant& operator=(variant&&) noexcept(see below);
-
-    template <class T> variant& operator=(T&&) noexcept(see below);
-
-    // 20.7.2.4, modifiers
-    template <class T, class... Args>
-    T& emplace(Args&&...);
-
-    template <class T, class U, class... Args>
-    T& emplace(initializer_list<U>, Args&&...);
-
-    template <size_t I, class... Args>
-    variant_alternative<I, variant>& emplace(Args&&...);
-
-    template <size_t I, class U, class...  Args>
-    variant_alternative<I, variant>& emplace(initializer_list<U>, Args&&...);
-
-    // 20.7.2.5, value status
-    constexpr bool valueless_by_exception() const noexcept;
-    constexpr size_t index() const noexcept;
-
-    // 20.7.2.6, swap
-    void swap(variant&) noexcept(see below);
-  };
-
-  // 20.7.3, variant helper classes
-  template <class T> struct variant_size; // undefined
-
-  template <class T>
-  constexpr size_t variant_size_v = variant_size<T>::value;
-
-  template <class T> struct variant_size<const T>;
-  template <class T> struct variant_size<volatile T>;
-  template <class T> struct variant_size<const volatile T>;
-
-  template <class... Types>
-  struct variant_size<variant<Types...>>;
-
-  template <size_t I, class T> struct variant_alternative; // undefined
-
-  template <size_t I, class T>
-  using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-  template <size_t I, class T> struct variant_alternative<I, const T>;
-  template <size_t I, class T> struct variant_alternative<I, volatile T>;
-  template <size_t I, class T> struct variant_alternative<I, const volatile T>;
-
-  template <size_t I, class... Types>
-  struct variant_alternative<I, variant<Types...>>;
-
-  constexpr size_t variant_npos = -1;
-
-  // 20.7.4, value access
-  template <class T, class... Types>
-  constexpr bool holds_alternative(const variant<Types...>&) noexcept;
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>>&
-  get(variant<Types...>&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>>&&
-  get(variant<Types...>&&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>> const&
-  get(const variant<Types...>&);
-
-  template <size_t I, class... Types>
-  constexpr variant_alternative_t<I, variant<Types...>> const&&
-  get(const variant<Types...>&&);
-
-  template <class T, class...  Types>
-  constexpr T& get(variant<Types...>&);
-
-  template <class T, class... Types>
-  constexpr T&& get(variant<Types...>&&);
-
-  template <class T, class... Types>
-  constexpr const T& get(const variant<Types...>&);
-
-  template <class T, class... Types>
-  constexpr const T&& get(const variant<Types...>&&);
-
-  template <size_t I, class... Types>
-  constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
-  get_if(variant<Types...>*) noexcept;
-
-  template <size_t I, class... Types>
-  constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
-  get_if(const variant<Types...>*) noexcept;
-
-  template <class T, class... Types>
-  constexpr add_pointer_t<T>
-  get_if(variant<Types...>*) noexcept;
-
-  template <class T, class... Types>
-  constexpr add_pointer_t<const T>
-  get_if(const variant<Types...>*) noexcept;
-
-  // 20.7.5, relational operators
-  template <class... Types>
-  constexpr bool operator==(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator!=(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator<(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator>(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator<=(const variant<Types...>&, const variant<Types...>&);
-
-  template <class... Types>
-  constexpr bool operator>=(const variant<Types...>&, const variant<Types...>&);
-
-  // 20.7.6, visitation
-  template <class Visitor, class... Variants>
-  constexpr see below visit(Visitor&&, Variants&&...);
-
-  // 20.7.7, class monostate
-  struct monostate;
-
-  // 20.7.8, monostate relational operators
-  constexpr bool operator<(monostate, monostate) noexcept;
-  constexpr bool operator>(monostate, monostate) noexcept;
-  constexpr bool operator<=(monostate, monostate) noexcept;
-  constexpr bool operator>=(monostate, monostate) noexcept;
-  constexpr bool operator==(monostate, monostate) noexcept;
-  constexpr bool operator!=(monostate, monostate) noexcept;
-
-  // 20.7.9, specialized algorithms
-  template <class... Types>
-  void swap(variant<Types...>&, variant<Types...>&) noexcept(see below);
-
-  // 20.7.10, class bad_variant_access
-  class bad_variant_access;
-
-  // 20.7.11, hash support
-  template <class T> struct hash;
-  template <class... Types> struct hash<variant<Types...>>;
-  template <> struct hash<monostate>;
-
-} // namespace std
-
-*/
-
-#include <cstddef>
-#include <exception>
-#include <functional>
-#include <initializer_list>
-#include <new>
-#include <type_traits>
-#include <utility>
-
-#include "config.hpp"
-#include "in_place.hpp"
-#include "lib.hpp"
-
-namespace mpark {
-
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-
-#define AUTO auto
-#define AUTO_RETURN(...) { return __VA_ARGS__; }
-
-#define AUTO_REFREF auto &&
-#define AUTO_REFREF_RETURN(...) { return __VA_ARGS__; }
-
-#define DECLTYPE_AUTO decltype(auto)
-#define DECLTYPE_AUTO_RETURN(...) { return __VA_ARGS__; }
-
-#else
-
-#define AUTO auto
-#define AUTO_RETURN(...) \
-  -> lib::decay_t<decltype(__VA_ARGS__)> { return __VA_ARGS__; }
-
-#define AUTO_REFREF auto
-#define AUTO_REFREF_RETURN(...)                                           \
-  -> decltype((__VA_ARGS__)) {                                            \
-    static_assert(std::is_reference<decltype((__VA_ARGS__))>::value, ""); \
-    return __VA_ARGS__;                                                   \
-  }
-
-#define DECLTYPE_AUTO auto
-#define DECLTYPE_AUTO_RETURN(...) \
-  -> decltype(__VA_ARGS__) { return __VA_ARGS__; }
-
-#endif
-
-  class bad_variant_access : public std::exception {
-    public:
-    virtual const char *what() const noexcept { return "bad_variant_access"; }
-  };
-
-  [[noreturn]] inline void throw_bad_variant_access() {
-#ifdef MPARK_EXCEPTIONS
-    throw bad_variant_access{};
-#else
-    std::terminate();
-#endif
-  }
-
-  template <typename... Ts>
-  class variant;
-
-  template <typename T>
-  struct variant_size;
-
-#ifdef MPARK_VARIABLE_TEMPLATES
-  template <typename T>
-  constexpr std::size_t variant_size_v = variant_size<T>::value;
-#endif
-
-  template <typename T>
-  struct variant_size<const T> : variant_size<T> {};
-
-  template <typename T>
-  struct variant_size<volatile T> : variant_size<T> {};
-
-  template <typename T>
-  struct variant_size<const volatile T> : variant_size<T> {};
-
-  template <typename... Ts>
-  struct variant_size<variant<Ts...>> : lib::size_constant<sizeof...(Ts)> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative;
-
-  template <std::size_t I, typename T>
-  using variant_alternative_t = typename variant_alternative<I, T>::type;
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const T>
-      : std::add_const<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, volatile T>
-      : std::add_volatile<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename T>
-  struct variant_alternative<I, const volatile T>
-      : std::add_cv<variant_alternative_t<I, T>> {};
-
-  template <std::size_t I, typename... Ts>
-  struct variant_alternative<I, variant<Ts...>> {
-    static_assert(I < sizeof...(Ts),
-                  "Index out of bounds in std::variant_alternative<>");
-    using type = lib::type_pack_element_t<I, Ts...>;
-  };
-
-  constexpr std::size_t variant_npos = static_cast<std::size_t>(-1);
-
-  namespace detail {
-
-    inline constexpr bool all() { return true; }
-
-    template <typename... Bs>
-    inline constexpr bool all(bool b, Bs... bs) {
-      return b && all(bs...);
-    }
-
-    constexpr std::size_t not_found = static_cast<std::size_t>(-1);
-    constexpr std::size_t ambiguous = static_cast<std::size_t>(-2);
-
-#ifdef MPARK_CPP14_CONSTEXPR
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      constexpr lib::array<bool, sizeof...(Ts)> matches = {
-          {std::is_same<T, Ts>::value...}
-      };
-      std::size_t result = not_found;
-      for (std::size_t i = 0; i < sizeof...(Ts); ++i) {
-        if (matches[i]) {
-          if (result != not_found) {
-            return ambiguous;
-          }
-          result = i;
-        }
-      }
-      return result;
-    }
-#else
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t) {
-      return result;
-    }
-
-    template <typename... Bs>
-    inline constexpr std::size_t find_index_impl(std::size_t result,
-                                                 std::size_t idx,
-                                                 bool b,
-                                                 Bs... bs) {
-      return b ? (result != not_found ? ambiguous
-                                      : find_index_impl(idx, idx + 1, bs...))
-               : find_index_impl(result, idx + 1, bs...);
-    }
-
-    template <typename T, typename... Ts>
-    inline constexpr std::size_t find_index() {
-      return find_index_impl(not_found, 0, std::is_same<T, Ts>::value...);
-    }
-#endif
-
-    template <std::size_t I>
-    using find_index_sfinae_impl =
-        lib::enable_if_t<I != not_found && I != ambiguous,
-                         lib::size_constant<I>>;
-
-    template <typename T, typename... Ts>
-    using find_index_sfinae = find_index_sfinae_impl<find_index<T, Ts...>()>;
-
-    template <std::size_t I>
-    struct find_index_checked_impl : lib::size_constant<I> {
-      static_assert(I != not_found, "the specified type is not found.");
-      static_assert(I != ambiguous, "the specified type is ambiguous.");
-    };
-
-    template <typename T, typename... Ts>
-    using find_index_checked = find_index_checked_impl<find_index<T, Ts...>()>;
-
-    struct valueless_t {};
-
-    enum class Trait { TriviallyAvailable, Available, Unavailable };
-
-    template <typename T,
-              template <typename> class IsTriviallyAvailable,
-              template <typename> class IsAvailable>
-    inline constexpr Trait trait() {
-      return IsTriviallyAvailable<T>::value
-                 ? Trait::TriviallyAvailable
-                 : IsAvailable<T>::value ? Trait::Available
-                                         : Trait::Unavailable;
-    }
-
-#ifdef MPARK_CPP14_CONSTEXPR
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... traits) {
-      Trait result = Trait::TriviallyAvailable;
-      for (Trait t : {traits...}) {
-        if (static_cast<int>(t) > static_cast<int>(result)) {
-          result = t;
-        }
-      }
-      return result;
-    }
-#else
-    inline constexpr Trait common_trait_impl(Trait result) { return result; }
-
-    template <typename... Traits>
-    inline constexpr Trait common_trait_impl(Trait result,
-                                             Trait t,
-                                             Traits... ts) {
-      return static_cast<int>(t) > static_cast<int>(result)
-                 ? common_trait_impl(t, ts...)
-                 : common_trait_impl(result, ts...);
-    }
-
-    template <typename... Traits>
-    inline constexpr Trait common_trait(Traits... ts) {
-      return common_trait_impl(Trait::TriviallyAvailable, ts...);
-    }
-#endif
-
-    template <typename... Ts>
-    struct traits {
-      static constexpr Trait copy_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_copy_constructible,
-                             std::is_copy_constructible>()...);
-
-      static constexpr Trait move_constructible_trait =
-          common_trait(trait<Ts,
-                             lib::is_trivially_move_constructible,
-                             std::is_move_constructible>()...);
-
-      static constexpr Trait copy_assignable_trait =
-          common_trait(copy_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_copy_assignable,
-                             std::is_copy_assignable>()...);
-
-      static constexpr Trait move_assignable_trait =
-          common_trait(move_constructible_trait,
-                       trait<Ts,
-                             lib::is_trivially_move_assignable,
-                             std::is_move_assignable>()...);
-
-      static constexpr Trait destructible_trait =
-          common_trait(trait<Ts,
-                             std::is_trivially_destructible,
-                             std::is_destructible>()...);
-    };
-
-    namespace access {
-
-      struct recursive_union {
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename V>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<0>) {
-          return lib::forward<V>(v).head_;
-        }
-
-        template <typename V, std::size_t I>
-        inline static constexpr auto &&get_alt(V &&v, in_place_index_t<I>) {
-          return get_alt(lib::forward<V>(v).tail_, in_place_index_t<I - 1>{});
-        }
-#else
-        template <std::size_t I, bool Dummy = true>
-        struct get_alt_impl {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(get_alt_impl<I - 1>{}(lib::forward<V>(v).tail_))
-        };
-
-        template <bool Dummy>
-        struct get_alt_impl<0, Dummy> {
-          template <typename V>
-          inline constexpr AUTO_REFREF operator()(V &&v) const
-            AUTO_REFREF_RETURN(lib::forward<V>(v).head_)
-        };
-
-        template <typename V, std::size_t I>
-        inline static constexpr AUTO_REFREF get_alt(V &&v, in_place_index_t<I>)
-          AUTO_REFREF_RETURN(get_alt_impl<I>{}(lib::forward<V>(v)))
-#endif
-      };
-
-      struct base {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
-          AUTO_REFREF_RETURN(recursive_union::get_alt(
-              data(lib::forward<V>(v)), in_place_index_t<I>{}))
-      };
-
-      struct variant {
-        template <std::size_t I, typename V>
-        inline static constexpr AUTO_REFREF get_alt(V &&v)
-          AUTO_REFREF_RETURN(base::get_alt<I>(lib::forward<V>(v).impl_))
-      };
-
-    }  // namespace access
-
-    namespace visitation {
-
-      struct base {
-        private:
-        template <typename T>
-        inline static constexpr const T &at(const T &elem) {
-          return elem;
-        }
-
-        template <typename T, std::size_t N, typename... Is>
-        inline static constexpr const lib::remove_all_extents_t<T> &at(
-            const lib::array<T, N> &elems, std::size_t i, Is... is) {
-          return at(elems[i], is...);
-        }
-
-        template <typename F, typename... Fs>
-        inline static constexpr int visit_visitor_return_type_check() {
-          static_assert(all(std::is_same<F, Fs>::value...),
-                        "`mpark::visit` requires the visitor to have a single "
-                        "return type.");
-          return 0;
-        }
-
-        template <typename... Fs>
-        inline static constexpr lib::array<
-            lib::common_type_t<lib::decay_t<Fs>...>,
-            sizeof...(Fs)>
-        make_farray(Fs &&... fs) {
-          using result = lib::array<lib::common_type_t<lib::decay_t<Fs>...>,
-                                    sizeof...(Fs)>;
-          return visit_visitor_return_type_check<lib::decay_t<Fs>...>(),
-                 result{{lib::forward<Fs>(fs)...}};
-        }
-
-        template <std::size_t... Is>
-        struct dispatcher {
-          template <typename F, typename... Vs>
-          struct impl {
-            inline static constexpr DECLTYPE_AUTO dispatch(F f, Vs... vs)
-              DECLTYPE_AUTO_RETURN(lib::invoke(
-                  static_cast<F>(f),
-                  access::base::get_alt<Is>(static_cast<Vs>(vs))...))
-          };
-        };
-
-        template <typename F, typename... Vs, std::size_t... Is>
-        inline static constexpr AUTO make_dispatch(lib::index_sequence<Is...>)
-          AUTO_RETURN(&dispatcher<Is...>::template impl<F, Vs...>::dispatch)
-
-        template <std::size_t I, typename F, typename... Vs>
-        inline static constexpr AUTO make_fdiagonal_impl()
-          AUTO_RETURN(make_dispatch<F, Vs...>(
-              lib::index_sequence<lib::indexed_type<I, Vs>::value...>{}))
-
-        template <typename F, typename... Vs, std::size_t... Is>
-        inline static constexpr AUTO make_fdiagonal_impl(
-            lib::index_sequence<Is...>)
-          AUTO_RETURN(make_farray(make_fdiagonal_impl<Is, F, Vs...>()...))
-
-        template <typename F, typename V, typename... Vs>
-        inline static constexpr /* auto * */ auto make_fdiagonal()
-            -> decltype(make_fdiagonal_impl<F, V, Vs...>(
-                lib::make_index_sequence<lib::decay_t<V>::size()>{})) {
-          static_assert(
-              all((lib::decay_t<V>::size() == lib::decay_t<Vs>::size())...),
-              "all of the variants must be the same size.");
-          return make_fdiagonal_impl<F, V, Vs...>(
-              lib::make_index_sequence<lib::decay_t<V>::size()>{});
-        }
-
-#ifdef MPARK_RETURN_TYPE_DEDUCTION
-        template <typename F, typename... Vs, std::size_t... Is>
-        inline static constexpr auto make_fmatrix_impl(
-            lib::index_sequence<Is...> is) {
-          return make_dispatch<F, Vs...>(is);
-        }
-
-        template <typename F,
-                  typename... Vs,
-                  std::size_t... Is,
-                  std::size_t... Js,
-                  typename... Ls>
-        inline static constexpr auto make_fmatrix_impl(
-            lib::index_sequence<Is...>, lib::index_sequence<Js...>, Ls... ls) {
-          return make_farray(make_fmatrix_impl<F, Vs...>(
-              lib::index_sequence<Is..., Js>{}, ls...)...);
-        }
-
-        template <typename F, typename... Vs>
-        inline static constexpr auto make_fmatrix() {
-          return make_fmatrix_impl<F, Vs...>(
-              lib::index_sequence<>{},
-              lib::make_index_sequence<lib::decay_t<Vs>::size()>{}...);
-        }
-#else
-        template <typename F, typename... Vs>
-        struct make_fmatrix_impl {
-          template <typename...>
-          struct impl;
-
-          template <std::size_t... Is>
-          struct impl<lib::index_sequence<Is...>> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(
-                  make_dispatch<F, Vs...>(lib::index_sequence<Is...>{}))
-          };
-
-          template <std::size_t... Is, std::size_t... Js, typename... Ls>
-          struct impl<lib::index_sequence<Is...>,
-                      lib::index_sequence<Js...>,
-                      Ls...> {
-            inline constexpr AUTO operator()() const
-              AUTO_RETURN(make_farray(
-                  impl<lib::index_sequence<Is..., Js>, Ls...>{}()...))
-          };
-        };
-
-        template <typename F, typename... Vs>
-        inline static constexpr AUTO make_fmatrix()
-          AUTO_RETURN(
-              typename make_fmatrix_impl<F, Vs...>::template impl<
-                  lib::index_sequence<>,
-                  lib::make_index_sequence<lib::decay_t<Vs>::size()>...>{}())
-#endif
-
-        public:
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              at(make_fdiagonal<Visitor &&,
-                                decltype(as_base(lib::forward<Vs>(vs)))...>(),
-                 index)(lib::forward<Visitor>(visitor),
-                        as_base(lib::forward<Vs>(vs))...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              at(make_fmatrix<Visitor &&,
-                              decltype(as_base(lib::forward<Vs>(vs)))...>(),
-                 vs.index()...)(lib::forward<Visitor>(visitor),
-                                as_base(lib::forward<Vs>(vs))...))
-      };
-
-      struct variant {
-        private:
-        template <typename Visitor, typename... Values>
-        struct visit_exhaustive_visitor_check {
-          static_assert(
-              lib::is_invocable<Visitor, Values...>::value,
-              "`mpark::visit` requires the visitor to be exhaustive.");
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-          inline constexpr DECLTYPE_AUTO operator()(Visitor &&visitor,
-                                                    Values &&... values) const
-            DECLTYPE_AUTO_RETURN(lib::invoke(lib::forward<Visitor>(visitor),
-                                             lib::forward<Values>(values)...))
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-        };
-
-        template <typename Visitor>
-        struct value_visitor {
-          Visitor &&visitor_;
-
-          template <typename... Alts>
-          inline constexpr DECLTYPE_AUTO operator()(Alts &&... alts) const
-            DECLTYPE_AUTO_RETURN(
-                visit_exhaustive_visitor_check<
-                    Visitor,
-                    decltype((lib::forward<Alts>(alts).value))...>{}(
-                    lib::forward<Visitor>(visitor_),
-                    lib::forward<Alts>(alts).value...))
-        };
-
-        template <typename Visitor>
-        inline static constexpr AUTO make_value_visitor(Visitor &&visitor)
-          AUTO_RETURN(value_visitor<Visitor>{lib::forward<Visitor>(visitor)})
-
-        public:
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt_at(std::size_t index,
-                                                           Visitor &&visitor,
-                                                           Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              base::visit_alt_at(index,
-                                 lib::forward<Visitor>(visitor),
-                                 lib::forward<Vs>(vs).impl_...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_alt(Visitor &&visitor,
-                                                        Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(base::visit_alt(lib::forward<Visitor>(visitor),
-                                               lib::forward<Vs>(vs).impl_...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value_at(std::size_t index,
-                                                             Visitor &&visitor,
-                                                             Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt_at(index,
-                           make_value_visitor(lib::forward<Visitor>(visitor)),
-                           lib::forward<Vs>(vs)...))
-
-        template <typename Visitor, typename... Vs>
-        inline static constexpr DECLTYPE_AUTO visit_value(Visitor &&visitor,
-                                                          Vs &&... vs)
-          DECLTYPE_AUTO_RETURN(
-              visit_alt(make_value_visitor(lib::forward<Visitor>(visitor)),
-                        lib::forward<Vs>(vs)...))
-      };
-
-    }  // namespace visitation
-
-    template <std::size_t Index, typename T>
-    struct alt {
-      using value_type = T;
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244)
-#endif
-      template <typename... Args>
-      inline explicit constexpr alt(in_place_t, Args &&... args)
-          : value(lib::forward<Args>(args)...) {}
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-      T value;
-    };
-
-    template <Trait DestructibleTrait, std::size_t Index, typename... Ts>
-    union recursive_union;
-
-    template <Trait DestructibleTrait, std::size_t Index>
-    union recursive_union<DestructibleTrait, Index> {};
-
-#define MPARK_VARIANT_RECURSIVE_UNION(destructible_trait, destructor)      \
-  template <std::size_t Index, typename T, typename... Ts>                 \
-  union recursive_union<destructible_trait, Index, T, Ts...> {             \
-    public:                                                                \
-    inline explicit constexpr recursive_union(valueless_t) noexcept        \
-        : dummy_{} {}                                                      \
-                                                                           \
-    template <typename... Args>                                            \
-    inline explicit constexpr recursive_union(in_place_index_t<0>,         \
-                                              Args &&... args)             \
-        : head_(in_place_t{}, lib::forward<Args>(args)...) {}              \
-                                                                           \
-    template <std::size_t I, typename... Args>                             \
-    inline explicit constexpr recursive_union(in_place_index_t<I>,         \
-                                              Args &&... args)             \
-        : tail_(in_place_index_t<I - 1>{}, lib::forward<Args>(args)...) {} \
-                                                                           \
-    recursive_union(const recursive_union &) = default;                    \
-    recursive_union(recursive_union &&) = default;                         \
-                                                                           \
-    destructor                                                             \
-                                                                           \
-    recursive_union &operator=(const recursive_union &) = default;         \
-    recursive_union &operator=(recursive_union &&) = default;              \
-                                                                           \
-    private:                                                               \
-    char dummy_;                                                           \
-    alt<Index, T> head_;                                                   \
-    recursive_union<destructible_trait, Index + 1, Ts...> tail_;           \
-                                                                           \
-    friend struct access::recursive_union;                                 \
-  }
-
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::TriviallyAvailable,
-                                  ~recursive_union() = default;);
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Available,
-                                  ~recursive_union() {});
-    MPARK_VARIANT_RECURSIVE_UNION(Trait::Unavailable,
-                                  ~recursive_union() = delete;);
-
-#undef MPARK_VARIANT_RECURSIVE_UNION
-
-    using index_t = unsigned int;
-
-    template <Trait DestructibleTrait, typename... Ts>
-    class base {
-      public:
-      inline explicit constexpr base(valueless_t tag) noexcept
-          : data_(tag), index_(static_cast<index_t>(-1)) {}
-
-      template <std::size_t I, typename... Args>
-      inline explicit constexpr base(in_place_index_t<I>, Args &&... args)
-          : data_(in_place_index_t<I>{}, lib::forward<Args>(args)...),
-            index_(I) {}
-
-      inline constexpr bool valueless_by_exception() const noexcept {
-        return index_ == static_cast<index_t>(-1);
-      }
-
-      inline constexpr std::size_t index() const noexcept {
-        return valueless_by_exception() ? variant_npos : index_;
-      }
-
-      protected:
-      using data_t = recursive_union<DestructibleTrait, 0, Ts...>;
-
-      friend inline constexpr base &as_base(base &b) { return b; }
-      friend inline constexpr const base &as_base(const base &b) { return b; }
-      friend inline constexpr base &&as_base(base &&b) { return lib::move(b); }
-      friend inline constexpr const base &&as_base(const base &&b) { return lib::move(b); }
-
-      friend inline constexpr data_t &data(base &b) { return b.data_; }
-      friend inline constexpr const data_t &data(const base &b) { return b.data_; }
-      friend inline constexpr data_t &&data(base &&b) { return lib::move(b).data_; }
-      friend inline constexpr const data_t &&data(const base &&b) { return lib::move(b).data_; }
-
-      inline static constexpr std::size_t size() { return sizeof...(Ts); }
-
-      data_t data_;
-      index_t index_;
-
-      friend struct access::base;
-      friend struct visitation::base;
-    };
-
-    struct dtor {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4100)
-#endif
-      template <typename Alt>
-      inline void operator()(Alt &alt) const noexcept { alt.~Alt(); }
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-    };
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-#define INHERITING_CTOR(type, base)               \
-  template <typename... Args>                     \
-  inline explicit constexpr type(Args &&... args) \
-      : base(lib::forward<Args>(args)...) {}
-#else
-#define INHERITING_CTOR(type, base) using base::base;
-#endif
-
-    template <typename Traits, Trait = Traits::destructible_trait>
-    class destructor;
-
-#define MPARK_VARIANT_DESTRUCTOR(destructible_trait, definition, destroy) \
-  template <typename... Ts>                                               \
-  class destructor<traits<Ts...>, destructible_trait>                     \
-      : public base<destructible_trait, Ts...> {                          \
-    using super = base<destructible_trait, Ts...>;                        \
-                                                                          \
-    public:                                                               \
-    INHERITING_CTOR(destructor, super)                                    \
-    using super::operator=;                                               \
-                                                                          \
-    destructor(const destructor &) = default;                             \
-    destructor(destructor &&) = default;                                  \
-    definition                                                            \
-    destructor &operator=(const destructor &) = default;                  \
-    destructor &operator=(destructor &&) = default;                       \
-                                                                          \
-    protected:                                                            \
-    destroy                                                               \
-  }
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::TriviallyAvailable,
-        ~destructor() = default;,
-        inline void destroy() noexcept {
-          this->index_ = static_cast<index_t>(-1);
-        });
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Available,
-        ~destructor() { destroy(); },
-        inline void destroy() noexcept {
-          if (!this->valueless_by_exception()) {
-            visitation::base::visit_alt(dtor{}, *this);
-          }
-          this->index_ = static_cast<index_t>(-1);
-        });
-
-    MPARK_VARIANT_DESTRUCTOR(
-        Trait::Unavailable,
-        ~destructor() = delete;,
-        inline void destroy() noexcept = delete;);
-
-#undef MPARK_VARIANT_DESTRUCTOR
-
-    template <typename Traits>
-    class constructor : public destructor<Traits> {
-      using super = destructor<Traits>;
-
-      public:
-      INHERITING_CTOR(constructor, super)
-      using super::operator=;
-
-      protected:
-#ifndef MPARK_GENERIC_LAMBDAS
-      struct ctor {
-        template <typename LhsAlt, typename RhsAlt>
-        inline void operator()(LhsAlt &lhs_alt, RhsAlt &&rhs_alt) const {
-          constructor::construct_alt(lhs_alt,
-                                     lib::forward<RhsAlt>(rhs_alt).value);
-        }
-      };
-#endif
-
-      template <std::size_t I, typename T, typename... Args>
-      inline static T &construct_alt(alt<I, T> &a, Args &&... args) {
-        ::new (static_cast<void *>(lib::addressof(a)))
-            alt<I, T>(in_place_t{}, lib::forward<Args>(args)...);
-        return a.value;
-      }
-
-      template <typename Rhs>
-      inline static void generic_construct(constructor &lhs, Rhs &&rhs) {
-        lhs.destroy();
-        if (!rhs.valueless_by_exception()) {
-          visitation::base::visit_alt_at(
-              rhs.index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-              [](auto &lhs_alt, auto &&rhs_alt) {
-                constructor::construct_alt(
-                    lhs_alt, lib::forward<decltype(rhs_alt)>(rhs_alt).value);
-              }
-#else
-              ctor{}
-#endif
-              ,
-              lhs,
-              lib::forward<Rhs>(rhs));
-          lhs.index_ = rhs.index_;
-        }
-      }
-    };
-
-    template <typename Traits, Trait = Traits::move_constructible_trait>
-    class move_constructor;
-
-#define MPARK_VARIANT_MOVE_CONSTRUCTOR(move_constructible_trait, definition) \
-  template <typename... Ts>                                                  \
-  class move_constructor<traits<Ts...>, move_constructible_trait>            \
-      : public constructor<traits<Ts...>> {                                  \
-    using super = constructor<traits<Ts...>>;                                \
-                                                                             \
-    public:                                                                  \
-    INHERITING_CTOR(move_constructor, super)                                 \
-    using super::operator=;                                                  \
-                                                                             \
-    move_constructor(const move_constructor &) = default;                    \
-    definition                                                               \
-    ~move_constructor() = default;                                           \
-    move_constructor &operator=(const move_constructor &) = default;         \
-    move_constructor &operator=(move_constructor &&) = default;              \
-  }
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        move_constructor(move_constructor &&that) = default;);
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Available,
-        move_constructor(move_constructor &&that) noexcept(
-            all(std::is_nothrow_move_constructible<Ts>::value...))
-            : move_constructor(valueless_t{}) {
-          this->generic_construct(*this, lib::move(that));
-        });
-
-    MPARK_VARIANT_MOVE_CONSTRUCTOR(
-        Trait::Unavailable,
-        move_constructor(move_constructor &&) = delete;);
-
-#undef MPARK_VARIANT_MOVE_CONSTRUCTOR
-
-    template <typename Traits, Trait = Traits::copy_constructible_trait>
-    class copy_constructor;
-
-#define MPARK_VARIANT_COPY_CONSTRUCTOR(copy_constructible_trait, definition) \
-  template <typename... Ts>                                                  \
-  class copy_constructor<traits<Ts...>, copy_constructible_trait>            \
-      : public move_constructor<traits<Ts...>> {                             \
-    using super = move_constructor<traits<Ts...>>;                           \
-                                                                             \
-    public:                                                                  \
-    INHERITING_CTOR(copy_constructor, super)                                 \
-    using super::operator=;                                                  \
-                                                                             \
-    definition                                                               \
-    copy_constructor(copy_constructor &&) = default;                         \
-    ~copy_constructor() = default;                                           \
-    copy_constructor &operator=(const copy_constructor &) = default;         \
-    copy_constructor &operator=(copy_constructor &&) = default;              \
-  }
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::TriviallyAvailable,
-        copy_constructor(const copy_constructor &that) = default;);
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Available,
-        copy_constructor(const copy_constructor &that)
-            : copy_constructor(valueless_t{}) {
-          this->generic_construct(*this, that);
-        });
-
-    MPARK_VARIANT_COPY_CONSTRUCTOR(
-        Trait::Unavailable,
-        copy_constructor(const copy_constructor &) = delete;);
-
-#undef MPARK_VARIANT_COPY_CONSTRUCTOR
-
-    template <typename Traits>
-    class assignment : public copy_constructor<Traits> {
-      using super = copy_constructor<Traits>;
-
-      public:
-      INHERITING_CTOR(assignment, super)
-      using super::operator=;
-
-      template <std::size_t I, typename... Args>
-      inline /* auto & */ auto emplace(Args &&... args)
-          -> decltype(this->construct_alt(access::base::get_alt<I>(*this),
-                                          lib::forward<Args>(args)...)) {
-        this->destroy();
-        auto &result = this->construct_alt(access::base::get_alt<I>(*this),
-                                           lib::forward<Args>(args)...);
-        this->index_ = I;
-        return result;
-      }
-
-      protected:
-#ifndef MPARK_GENERIC_LAMBDAS
-      template <typename That>
-      struct assigner {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &&that_alt) const {
-          self->assign_alt(this_alt, lib::forward<ThatAlt>(that_alt).value);
-        }
-        assignment *self;
-      };
-#endif
-
-      template <std::size_t I, typename T, typename Arg>
-      inline void assign_alt(alt<I, T> &a, Arg &&arg) {
-        if (this->index() == I) {
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244)
-#endif
-          a.value = lib::forward<Arg>(arg);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-        } else {
-          struct {
-            void operator()(std::true_type) const {
-              this_->emplace<I>(lib::forward<Arg>(arg_));
-            }
-            void operator()(std::false_type) const {
-              this_->emplace<I>(T(lib::forward<Arg>(arg_)));
-            }
-            assignment *this_;
-            Arg &&arg_;
-          } impl{this, lib::forward<Arg>(arg)};
-          impl(lib::bool_constant<
-                   std::is_nothrow_constructible<T, Arg>::value ||
-                   !std::is_nothrow_move_constructible<T>::value>{});
-        }
-      }
-
-      template <typename That>
-      inline void generic_assign(That &&that) {
-        if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
-        } else if (that.valueless_by_exception()) {
-          this->destroy();
-        } else {
-          visitation::base::visit_alt_at(
-              that.index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-              [this](auto &this_alt, auto &&that_alt) {
-                this->assign_alt(
-                    this_alt, lib::forward<decltype(that_alt)>(that_alt).value);
-              }
-#else
-              assigner<That>{this}
-#endif
-              ,
-              *this,
-              lib::forward<That>(that));
-        }
-      }
-    };
-
-    template <typename Traits, Trait = Traits::move_assignable_trait>
-    class move_assignment;
-
-#define MPARK_VARIANT_MOVE_ASSIGNMENT(move_assignable_trait, definition) \
-  template <typename... Ts>                                              \
-  class move_assignment<traits<Ts...>, move_assignable_trait>            \
-      : public assignment<traits<Ts...>> {                               \
-    using super = assignment<traits<Ts...>>;                             \
-                                                                         \
-    public:                                                              \
-    INHERITING_CTOR(move_assignment, super)                              \
-    using super::operator=;                                              \
-                                                                         \
-    move_assignment(const move_assignment &) = default;                  \
-    move_assignment(move_assignment &&) = default;                       \
-    ~move_assignment() = default;                                        \
-    move_assignment &operator=(const move_assignment &) = default;       \
-    definition                                                           \
-  }
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        move_assignment &operator=(move_assignment &&that) = default;);
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Available,
-        move_assignment &
-        operator=(move_assignment &&that) noexcept(
-            all((std::is_nothrow_move_constructible<Ts>::value &&
-                 std::is_nothrow_move_assignable<Ts>::value)...)) {
-          this->generic_assign(lib::move(that));
-          return *this;
-        });
-
-    MPARK_VARIANT_MOVE_ASSIGNMENT(
-        Trait::Unavailable,
-        move_assignment &operator=(move_assignment &&) = delete;);
-
-#undef MPARK_VARIANT_MOVE_ASSIGNMENT
-
-    template <typename Traits, Trait = Traits::copy_assignable_trait>
-    class copy_assignment;
-
-#define MPARK_VARIANT_COPY_ASSIGNMENT(copy_assignable_trait, definition) \
-  template <typename... Ts>                                              \
-  class copy_assignment<traits<Ts...>, copy_assignable_trait>            \
-      : public move_assignment<traits<Ts...>> {                          \
-    using super = move_assignment<traits<Ts...>>;                        \
-                                                                         \
-    public:                                                              \
-    INHERITING_CTOR(copy_assignment, super)                              \
-    using super::operator=;                                              \
-                                                                         \
-    copy_assignment(const copy_assignment &) = default;                  \
-    copy_assignment(copy_assignment &&) = default;                       \
-    ~copy_assignment() = default;                                        \
-    definition                                                           \
-    copy_assignment &operator=(copy_assignment &&) = default;            \
-  }
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::TriviallyAvailable,
-        copy_assignment &operator=(const copy_assignment &that) = default;);
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Available,
-        copy_assignment &operator=(const copy_assignment &that) {
-          this->generic_assign(that);
-          return *this;
-        });
-
-    MPARK_VARIANT_COPY_ASSIGNMENT(
-        Trait::Unavailable,
-        copy_assignment &operator=(const copy_assignment &) = delete;);
-
-#undef MPARK_VARIANT_COPY_ASSIGNMENT
-
-    template <typename... Ts>
-    class impl : public copy_assignment<traits<Ts...>> {
-      using super = copy_assignment<traits<Ts...>>;
-
-      public:
-      INHERITING_CTOR(impl, super)
-      using super::operator=;
-
-      template <std::size_t I, typename Arg>
-      inline void assign(Arg &&arg) {
-        this->assign_alt(access::base::get_alt<I>(*this),
-                         lib::forward<Arg>(arg));
-      }
-
-      inline void swap(impl &that) {
-        if (this->valueless_by_exception() && that.valueless_by_exception()) {
-          // do nothing.
-        } else if (this->index() == that.index()) {
-          visitation::base::visit_alt_at(this->index(),
-#ifdef MPARK_GENERIC_LAMBDAS
-                                         [](auto &this_alt, auto &that_alt) {
-                                           using std::swap;
-                                           swap(this_alt.value,
-                                                that_alt.value);
-                                         }
-#else
-                                         swapper{}
-#endif
-                                         ,
-                                         *this,
-                                         that);
-        } else {
-          impl *lhs = this;
-          impl *rhs = lib::addressof(that);
-          if (lhs->move_nothrow() && !rhs->move_nothrow()) {
-            std::swap(lhs, rhs);
-          }
-          impl tmp(lib::move(*rhs));
-#ifdef MPARK_EXCEPTIONS
-          // EXTENSION: When the move construction of `lhs` into `rhs` throws
-          // and `tmp` is nothrow move constructible then we move `tmp` back
-          // into `rhs` and provide the strong exception safety guarantee.
-          try {
-            this->generic_construct(*rhs, lib::move(*lhs));
-          } catch (...) {
-            if (tmp.move_nothrow()) {
-              this->generic_construct(*rhs, lib::move(tmp));
-            }
-            throw;
-          }
-#else
-          this->generic_construct(*rhs, lib::move(*lhs));
-#endif
-          this->generic_construct(*lhs, lib::move(tmp));
-        }
-      }
-
-      private:
-#ifndef MPARK_GENERIC_LAMBDAS
-      struct swapper {
-        template <typename ThisAlt, typename ThatAlt>
-        inline void operator()(ThisAlt &this_alt, ThatAlt &that_alt) const {
-          using std::swap;
-          swap(this_alt.value, that_alt.value);
-        }
-      };
-#endif
-
-      inline constexpr bool move_nothrow() const {
-        return this->valueless_by_exception() ||
-               lib::array<bool, sizeof...(Ts)>{
-                   {std::is_nothrow_move_constructible<Ts>::value...}
-               }[this->index()];
-      }
-    };
-
-    template <typename... Ts>
-    struct overload;
-
-    template <>
-    struct overload<> { void operator()() const {} };
-
-    template <typename T, typename... Ts>
-    struct overload<T, Ts...> : overload<Ts...> {
-      using overload<Ts...>::operator();
-      lib::identity<T> operator()(T) const { return {}; }
-    };
-
-    template <typename T, typename... Ts>
-    using best_match_t =
-        typename lib::invoke_result_t<overload<Ts...>, T &&>::type;
-
-    template <typename T>
-    struct is_in_place_index : std::false_type {};
-
-    template <std::size_t I>
-    struct is_in_place_index<in_place_index_t<I>> : std::true_type {};
-
-    template <typename T>
-    struct is_in_place_type : std::false_type {};
-
-    template <typename T>
-    struct is_in_place_type<in_place_type_t<T>> : std::true_type {};
-
-  }  // detail
-
-  template <typename... Ts>
-  class variant {
-    static_assert(0 < sizeof...(Ts),
-                  "variant must consist of at least one alternative.");
-
-    static_assert(lib::all<!std::is_array<Ts>::value...>::value,
-                  "variant can not have an array type as an alternative.");
-
-    static_assert(lib::all<!std::is_reference<Ts>::value...>::value,
-                  "variant can not have a reference type as an alternative.");
-
-    static_assert(lib::all<!std::is_void<Ts>::value...>::value,
-                  "variant can not have a void type as an alternative.");
-
-    public:
-    template <
-        typename Front = lib::type_pack_element_t<0, Ts...>,
-        lib::enable_if_t<std::is_default_constructible<Front>::value, int> = 0>
-    inline constexpr variant() noexcept(
-        std::is_nothrow_default_constructible<Front>::value)
-        : impl_(in_place_index_t<0>{}) {}
-
-    variant(const variant &) = default;
-    variant(variant &&) = default;
-
-    template <
-        typename Arg,
-        typename Decayed = lib::decay_t<Arg>,
-        lib::enable_if_t<!std::is_same<Decayed, variant>::value, int> = 0,
-        lib::enable_if_t<!detail::is_in_place_index<Decayed>::value, int> = 0,
-        lib::enable_if_t<!detail::is_in_place_type<Decayed>::value, int> = 0,
-        typename T = detail::best_match_t<Arg, Ts...>,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Arg>::value, int> = 0>
-    inline constexpr variant(Arg &&arg) noexcept(
-        std::is_nothrow_constructible<T, Arg>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Arg>(arg)) {}
-
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_index_t<I>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        Args &&... args) noexcept(std::is_nothrow_constructible<T,
-                                                                Args...>::value)
-        : impl_(in_place_index_t<I>{}, lib::forward<Args>(args)...) {}
-
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline explicit constexpr variant(
-        in_place_type_t<T>,
-        std::initializer_list<Up> il,
-        Args &&... args) noexcept(std::
-                                      is_nothrow_constructible<
-                                          T,
-                                          std::initializer_list<Up> &,
-                                          Args...>::value)
-        : impl_(in_place_index_t<I>{}, il, lib::forward<Args>(args)...) {}
-
-    ~variant() = default;
-
-    variant &operator=(const variant &) = default;
-    variant &operator=(variant &&) = default;
-
-    template <typename Arg,
-              lib::enable_if_t<!std::is_same<lib::decay_t<Arg>, variant>::value,
-                               int> = 0,
-              typename T = detail::best_match_t<Arg, Ts...>,
-              std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-              lib::enable_if_t<(std::is_assignable<T &, Arg>::value &&
-                                std::is_constructible<T, Arg>::value),
-                               int> = 0>
-    inline variant &operator=(Arg &&arg) noexcept(
-        (std::is_nothrow_assignable<T &, Arg>::value &&
-         std::is_nothrow_constructible<T, Arg>::value)) {
-      impl_.template assign<I>(lib::forward<Arg>(arg));
-      return *this;
-    }
-
-    template <
-        std::size_t I,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
-    }
-
-    template <
-        std::size_t I,
-        typename Up,
-        typename... Args,
-        typename T = lib::type_pack_element_t<I, Ts...>,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
-    }
-
-    template <
-        typename T,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T, Args...>::value, int> = 0>
-    inline T &emplace(Args &&... args) {
-      return impl_.template emplace<I>(lib::forward<Args>(args)...);
-    }
-
-    template <
-        typename T,
-        typename Up,
-        typename... Args,
-        std::size_t I = detail::find_index_sfinae<T, Ts...>::value,
-        lib::enable_if_t<std::is_constructible<T,
-                                               std::initializer_list<Up> &,
-                                               Args...>::value,
-                         int> = 0>
-    inline T &emplace(std::initializer_list<Up> il, Args &&... args) {
-      return impl_.template emplace<I>(il, lib::forward<Args>(args)...);
-    }
-
-    inline constexpr bool valueless_by_exception() const noexcept {
-      return impl_.valueless_by_exception();
-    }
-
-    inline constexpr std::size_t index() const noexcept {
-      return impl_.index();
-    }
-
-    template <
-        bool Dummy = true,
-        lib::enable_if_t<lib::all<Dummy,
-                                  (std::is_move_constructible<Ts>::value &&
-                                   lib::is_swappable<Ts>::value)...>::value,
-                         int> = 0>
-    inline void swap(variant &that) noexcept(
-        lib::all<(std::is_nothrow_move_constructible<Ts>::value &&
-                  lib::is_nothrow_swappable<Ts>::value)...>::value) {
-      impl_.swap(that.impl_);
-    }
-
-    private:
-    detail::impl<Ts...> impl_;
-
-    friend struct detail::access::variant;
-    friend struct detail::visitation::variant;
-  };
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
-    return v.index() == I;
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr bool holds_alternative(const variant<Ts...> &v) noexcept {
-    return holds_alternative<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  namespace detail {
-    template <std::size_t I, typename V>
-    struct generic_get_impl {
-      constexpr generic_get_impl(int) {}
-
-      constexpr AUTO_REFREF operator()(V &&v) const
-        AUTO_REFREF_RETURN(
-            access::variant::get_alt<I>(lib::forward<V>(v)).value)
-    };
-
-    template <std::size_t I, typename V>
-    inline constexpr AUTO_REFREF generic_get(V &&v)
-      AUTO_REFREF_RETURN(generic_get_impl<I, V>(
-          holds_alternative<I>(v) ? 0 : (throw_bad_variant_access(), 0))(
-          lib::forward<V>(v)))
-  }  // namespace detail
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &get(
-      variant<Ts...> &v) {
-    return detail::generic_get<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr variant_alternative_t<I, variant<Ts...>> &&get(
-      variant<Ts...> &&v) {
-    return detail::generic_get<I>(lib::move(v));
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &get(
-      const variant<Ts...> &v) {
-    return detail::generic_get<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr const variant_alternative_t<I, variant<Ts...>> &&get(
-      const variant<Ts...> &&v) {
-    return detail::generic_get<I>(lib::move(v));
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr T &get(variant<Ts...> &v) {
-    return get<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr T &&get(variant<Ts...> &&v) {
-    return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr const T &get(const variant<Ts...> &v) {
-    return get<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr const T &&get(const variant<Ts...> &&v) {
-    return get<detail::find_index_checked<T, Ts...>::value>(lib::move(v));
-  }
-
-  namespace detail {
-
-    template <std::size_t I, typename V>
-    inline constexpr /* auto * */ AUTO generic_get_if(V *v) noexcept
-      AUTO_RETURN(v && holds_alternative<I>(*v)
-                      ? lib::addressof(access::variant::get_alt<I>(*v).value)
-                      : nullptr)
-
-  }  // namespace detail
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<variant_alternative_t<I, variant<Ts...>>>
-  get_if(variant<Ts...> *v) noexcept {
-    return detail::generic_get_if<I>(v);
-  }
-
-  template <std::size_t I, typename... Ts>
-  inline constexpr lib::add_pointer_t<
-      const variant_alternative_t<I, variant<Ts...>>>
-  get_if(const variant<Ts...> *v) noexcept {
-    return detail::generic_get_if<I>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<T>
-  get_if(variant<Ts...> *v) noexcept {
-    return get_if<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename T, typename... Ts>
-  inline constexpr lib::add_pointer_t<const T>
-  get_if(const variant<Ts...> *v) noexcept {
-    return get_if<detail::find_index_checked<T, Ts...>::value>(v);
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator==(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::equal_to;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.index() != rhs.index()) return false;
-    if (lhs.valueless_by_exception()) return true;
-    return variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs);
-#else
-    return lhs.index() == rhs.index() &&
-           (lhs.valueless_by_exception() ||
-            variant::visit_value_at(lhs.index(), equal_to{}, lhs, rhs));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator!=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::not_equal_to;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.index() != rhs.index()) return true;
-    if (lhs.valueless_by_exception()) return false;
-    return variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs);
-#else
-    return lhs.index() != rhs.index() ||
-           (!lhs.valueless_by_exception() &&
-            variant::visit_value_at(lhs.index(), not_equal_to{}, lhs, rhs));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator<(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::less;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (rhs.valueless_by_exception()) return false;
-    if (lhs.valueless_by_exception()) return true;
-    if (lhs.index() < rhs.index()) return true;
-    if (lhs.index() > rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), less{}, lhs, rhs);
-#else
-    return !rhs.valueless_by_exception() &&
-           (lhs.valueless_by_exception() || lhs.index() < rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), less{}, lhs, rhs)));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator>(const variant<Ts...> &lhs,
-                                  const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::greater;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.valueless_by_exception()) return false;
-    if (rhs.valueless_by_exception()) return true;
-    if (lhs.index() > rhs.index()) return true;
-    if (lhs.index() < rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), greater{}, lhs, rhs);
-#else
-    return !lhs.valueless_by_exception() &&
-           (rhs.valueless_by_exception() || lhs.index() > rhs.index() ||
-            (lhs.index() == rhs.index() &&
-             variant::visit_value_at(lhs.index(), greater{}, lhs, rhs)));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator<=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::less_equal;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (lhs.valueless_by_exception()) return true;
-    if (rhs.valueless_by_exception()) return false;
-    if (lhs.index() < rhs.index()) return true;
-    if (lhs.index() > rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs);
-#else
-    return lhs.valueless_by_exception() ||
-           (!rhs.valueless_by_exception() &&
-            (lhs.index() < rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(lhs.index(), less_equal{}, lhs, rhs))));
-#endif
-  }
-
-  template <typename... Ts>
-  inline constexpr bool operator>=(const variant<Ts...> &lhs,
-                                   const variant<Ts...> &rhs) {
-    using detail::visitation::variant;
-    using lib::greater_equal;
-#ifdef MPARK_CPP14_CONSTEXPR
-    if (rhs.valueless_by_exception()) return true;
-    if (lhs.valueless_by_exception()) return false;
-    if (lhs.index() > rhs.index()) return true;
-    if (lhs.index() < rhs.index()) return false;
-    return variant::visit_value_at(lhs.index(), greater_equal{}, lhs, rhs);
-#else
-    return rhs.valueless_by_exception() ||
-           (!lhs.valueless_by_exception() &&
-            (lhs.index() > rhs.index() ||
-             (lhs.index() == rhs.index() &&
-              variant::visit_value_at(
-                  lhs.index(), greater_equal{}, lhs, rhs))));
-#endif
-  }
-
-  template <typename Visitor, typename... Vs>
-  inline constexpr DECLTYPE_AUTO visit(Visitor &&visitor, Vs &&... vs)
-    DECLTYPE_AUTO_RETURN(
-        (detail::all(!vs.valueless_by_exception()...)
-             ? (void)0
-             : throw_bad_variant_access()),
-        detail::visitation::variant::visit_value(lib::forward<Visitor>(visitor),
-                                                 lib::forward<Vs>(vs)...))
-
-  struct monostate {};
-
-  inline constexpr bool operator<(monostate, monostate) noexcept {
-    return false;
-  }
-
-  inline constexpr bool operator>(monostate, monostate) noexcept {
-    return false;
-  }
-
-  inline constexpr bool operator<=(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator>=(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator==(monostate, monostate) noexcept {
-    return true;
-  }
-
-  inline constexpr bool operator!=(monostate, monostate) noexcept {
-    return false;
-  }
-
-  template <typename... Ts>
-  inline auto swap(variant<Ts...> &lhs,
-                   variant<Ts...> &rhs) noexcept(noexcept(lhs.swap(rhs)))
-      -> decltype(lhs.swap(rhs)) {
-    lhs.swap(rhs);
-  }
-
-  namespace detail {
-
-    template <typename T, typename...>
-    using enabled_type = T;
-
-    namespace hash {
-
-      template <typename H, typename K>
-      constexpr bool meets_requirements() {
-        return std::is_copy_constructible<H>::value &&
-               std::is_move_constructible<H>::value &&
-               lib::is_invocable_r<std::size_t, H, const K &>::value;
-      }
-
-      template <typename K>
-      constexpr bool is_enabled() {
-        using H = std::hash<K>;
-        return meets_requirements<H, K>() &&
-               std::is_default_constructible<H>::value &&
-               std::is_copy_assignable<H>::value &&
-               std::is_move_assignable<H>::value;
-      }
-
-    }  // namespace hash
-
-  }  // namespace detail
-
-#undef AUTO
-#undef AUTO_RETURN
-
-#undef AUTO_REFREF
-#undef AUTO_REFREF_RETURN
-
-#undef DECLTYPE_AUTO
-#undef DECLTYPE_AUTO_RETURN
-
-}  // namespace mpark
-
-namespace std {
-
-  template <typename... Ts>
-  struct hash<mpark::detail::enabled_type<
-      mpark::variant<Ts...>,
-      mpark::lib::enable_if_t<mpark::lib::all<mpark::detail::hash::is_enabled<
-          mpark::lib::remove_const_t<Ts>>()...>::value>>> {
-    using argument_type = mpark::variant<Ts...>;
-    using result_type = std::size_t;
-
-    inline result_type operator()(const argument_type &v) const {
-      using mpark::detail::visitation::variant;
-      std::size_t result =
-          v.valueless_by_exception()
-              ? 299792458  // Random value chosen by the universe upon creation
-              : variant::visit_alt(
-#ifdef MPARK_GENERIC_LAMBDAS
-                    [](const auto &alt) {
-                      using alt_type = mpark::lib::decay_t<decltype(alt)>;
-                      using value_type = mpark::lib::remove_const_t<
-                          typename alt_type::value_type>;
-                      return hash<value_type>{}(alt.value);
-                    }
-#else
-                    hasher{}
-#endif
-                    ,
-                    v);
-      return hash_combine(result, hash<std::size_t>{}(v.index()));
-    }
-
-    private:
-#ifndef MPARK_GENERIC_LAMBDAS
-    struct hasher {
-      template <typename Alt>
-      inline std::size_t operator()(const Alt &alt) const {
-        using alt_type = mpark::lib::decay_t<Alt>;
-        using value_type =
-            mpark::lib::remove_const_t<typename alt_type::value_type>;
-        return hash<value_type>{}(alt.value);
-      }
-    };
-#endif
-
-    static std::size_t hash_combine(std::size_t lhs, std::size_t rhs) {
-      return lhs ^= rhs + 0x9e3779b9 + (lhs << 6) + (lhs >> 2);
-    }
-  };
-
-  template <>
-  struct hash<mpark::monostate> {
-    using argument_type = mpark::monostate;
-    using result_type = std::size_t;
-
-    inline result_type operator()(const argument_type &) const noexcept {
-      return 66740831;  // return a fundamentally attractive random value.
-    }
-  };
-
-}  // namespace std
-
-#endif  // MPARK_VARIANT_HPP
diff --git a/src/Block.hpp b/src/Block.hpp
index 367e559..6bd4e93 100644
--- a/src/Block.hpp
+++ b/src/Block.hpp
@@ -11,4 +11,9 @@ struct Block {
 	unsigned char state : 4;
     unsigned char light : 4;
     unsigned char sky : 4;
+};
+
+struct BlockId {
+    unsigned short id : 13;
+    unsigned char state : 4;
 };
\ No newline at end of file
diff --git a/src/Render.cpp b/src/Render.cpp
index 7e88068..c739b77 100644
--- a/src/Render.cpp
+++ b/src/Render.cpp
@@ -6,12 +6,12 @@
 #include "Event.hpp"
 
 Render::Render(unsigned int windowWidth, unsigned int windowHeight, std::string windowTitle) : timer(std::chrono::milliseconds(0)) {
-	InitSfml(windowWidth, windowHeight, windowTitle);
-	glCheckError();
-	InitGlew();
-	glCheckError();
-	PrepareToRendering();
-	glCheckError();
+    InitSfml(windowWidth, windowHeight, windowTitle);
+    glCheckError();
+    InitGlew();
+    glCheckError();
+    PrepareToRendering();
+    glCheckError();
 }
 
 Render::~Render() {
@@ -29,7 +29,8 @@ void Render::InitSfml(unsigned int WinWidth, unsigned int WinHeight, std::string
 	glCheckError();
 	window->setPosition(sf::Vector2i(sf::VideoMode::getDesktopMode().width / 2 - window->getSize().x / 2,
 	                                 sf::VideoMode::getDesktopMode().height / 2 - window->getSize().y / 2));
-	SetMouseCapture(false);
+    window->setKeyRepeatEnabled(false);
+	SetMouseCapture(false);    
     renderState.WindowWidth = WinWidth;
     renderState.WindowHeight = WinHeight;
 }
@@ -59,6 +60,23 @@ void Render::PrepareToRendering() {
     AssetManager::Instance().GetTextureAtlasIndexes();
 }
 
+void Render::UpdateKeyboard() {
+    sf::Keyboard::Key toUpdate[] = { sf::Keyboard::A,sf::Keyboard::W,sf::Keyboard::S,sf::Keyboard::D,sf::Keyboard::Space };
+    for (auto key : toUpdate) {
+        bool isPressed = sf::Keyboard::isKeyPressed(key);
+        if (!isKeyPressed[key] && isPressed) {
+            EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ key });
+        }
+        if (isKeyPressed[key] && isPressed) {
+            //KeyHeld
+        }
+        if (isKeyPressed[key] && !isPressed) {
+            EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ key });
+        }
+        isKeyPressed[key] = isPressed;
+    }
+}
+
 void Render::RenderFrame() {
 	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -75,92 +93,62 @@ void Render::RenderFrame() {
 
 void Render::HandleEvents() {
 	sf::Event event;
-	while (window->pollEvent(event)) {
-		switch (event.type) {
-			case sf::Event::Closed:
-				LOG(INFO) << "Received close event by window closing";
-				isRunning = false;
-				break;
-			case sf::Event::Resized:
-				glViewport(0, 0, window->getSize().x, window->getSize().y);
-                renderState.WindowWidth = window->getSize().x;
-                renderState.WindowHeight = window->getSize().y;
-				break;
-			case sf::Event::KeyPressed:
-				if (!window->hasFocus()) break;
-                switch (event.key.code) {
-                case sf::Keyboard::Escape:
-                    LOG(INFO) << "Received close event by esc";
-                    isRunning = false;
-                    break;
-                    case sf::Keyboard::T:
-                        SetMouseCapture(!isMouseCaptured);
-                        break;
-                    case sf::Keyboard::U:
-                        EventAgregator::PushEvent(EventType::ConnectToServer, ConnectToServerData{ "10.1.1.2", 25565 });
-                        break;
-                    case sf::Keyboard::I:
-                        EventAgregator::PushEvent(EventType::Disconnect, DisconnectData{ "Manual disconnect" });
-                        break;
-                    case sf::Keyboard::K:
-                        if (renderWorld) {
-                            world->MaxRenderingDistance--;
-                            if (world->MaxRenderingDistance <= 0)
-                                world->MaxRenderingDistance = 1;
-                            LOG(INFO) << "Decreased rendering distance: " << world->MaxRenderingDistance;
-                            EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
-                        }
-                    break;
-                    case sf::Keyboard::L:
-                        if (renderWorld) {
-                            world->MaxRenderingDistance++;
-                            LOG(INFO) << "Increased rendering distance: " << world->MaxRenderingDistance;
-                            EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
-                        }
-                        break;
-                    case sf::Keyboard::W:
-                        EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::W });
-                        break;
-                    case sf::Keyboard::A:
-                        EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::A });
-                        break;
-                    case sf::Keyboard::S:
-                        EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::S });
-                        break;
-                    case sf::Keyboard::D:
-                        EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::D });
-                        break;
-                    case sf::Keyboard::Space:
-                        EventAgregator::PushEvent(EventType::KeyPressed, KeyPressedData{ sf::Keyboard::Space });
-                        break;
-					default:
-						break;
-				}
-            case sf::Event::KeyReleased:
-                if (!window->hasFocus()) break;
-                switch (event.key.code) {
-                    case sf::Keyboard::W:
-                        EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::W });
-                        break;
-                    case sf::Keyboard::A:
-                        EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::A });
-                        break;
-                    case sf::Keyboard::S:
-                        EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::S });
-                        break;
-                    case sf::Keyboard::D:
-                        EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::D });
-                        break;
-                    case sf::Keyboard::Space:
-                        EventAgregator::PushEvent(EventType::KeyReleased, KeyReleasedData{ sf::Keyboard::Space });
-                        break;
-                    default:
-                        break;
+    while (window->pollEvent(event)) {
+        switch (event.type) {
+        case sf::Event::Closed:
+            LOG(INFO) << "Received close event by window closing";
+            isRunning = false;
+            break;
+        case sf::Event::Resized:
+            glViewport(0, 0, window->getSize().x, window->getSize().y);
+            renderState.WindowWidth = window->getSize().x;
+            renderState.WindowHeight = window->getSize().y;
+            break;
+        case sf::Event::KeyPressed:
+            if (!window->hasFocus()) break;
+            switch (event.key.code) {
+            case sf::Keyboard::Escape:
+                LOG(INFO) << "Received close event by esc";
+                isRunning = false;
+                break;
+            case sf::Keyboard::T:
+                SetMouseCapture(!isMouseCaptured);
+                break;
+            case sf::Keyboard::U:
+                EventAgregator::PushEvent(EventType::ConnectToServer, ConnectToServerData{ "10.1.1.2", 25565 });
+                break;
+            case sf::Keyboard::I:
+                EventAgregator::PushEvent(EventType::Disconnect, DisconnectData{ "Manual disconnect" });
+                break;
+            case sf::Keyboard::K:
+                if (renderWorld) {
+                    world->MaxRenderingDistance--;
+                    if (world->MaxRenderingDistance <= 0)
+                        world->MaxRenderingDistance = 1;
+                    LOG(INFO) << "Decreased rendering distance: " << world->MaxRenderingDistance;
+                    EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
                 }
-			default:
-				break;
-		}
-	}	
+                break;
+            case sf::Keyboard::L:
+                if (renderWorld) {
+                    world->MaxRenderingDistance++;
+                    LOG(INFO) << "Increased rendering distance: " << world->MaxRenderingDistance;
+                    EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
+                }
+                break;
+            default:
+                break;
+            }
+        case sf::Event::KeyReleased:
+            if (!window->hasFocus()) break;
+            switch (event.key.code) {
+            default:
+                break;
+            }
+        default:
+            break;
+        }
+    }
 }
 
 void Render::HandleMouseCapture() {
@@ -216,6 +204,7 @@ void Render::ExecuteRenderLoop() {
 	
 	while (isRunning) {
 		HandleEvents();
+        if (window->hasFocus()) UpdateKeyboard();
 		if (isMouseCaptured) HandleMouseCapture();
 		glCheckError();
 
@@ -223,10 +212,7 @@ void Render::ExecuteRenderLoop() {
 		while (listener.IsEventsQueueIsNotEmpty())
 			listener.HandleEvent();
         if (renderWorld) {
-            world->renderDataMutex.lock();
-            size_t size = world->renderData.size();
-            world->renderDataMutex.unlock();
-            window->setTitle("Size: " + std::to_string(size) + "  FPS: " + std::to_string(1.0 / timer.GetRealDeltaS()));
+            window->setTitle("FPS: " + std::to_string(1.0 / timer.GetRealDeltaS()));
         }
 		timer.Update();
 	}
diff --git a/src/Render.hpp b/src/Render.hpp
index 6b4b5a4..b7d12d0 100644
--- a/src/Render.hpp
+++ b/src/Render.hpp
@@ -4,16 +4,18 @@
 
 #include "Shader.hpp"
 #include "RendererWorld.hpp"
+#include "RendererWidget.hpp"
 
 class Render {
 	sf::Window *window;
-	bool isRunning=true;
+    bool isRunning = true;
 	bool isMouseCaptured = false;
 	float mouseXDelta, mouseYDelta;
     std::unique_ptr<RendererWorld> world; 
     bool renderWorld = false;
     RenderState renderState;
     LoopExecutionTimeController timer;
+    std::map<sf::Keyboard::Key, bool> isKeyPressed;
 
 	void SetMouseCapture(bool IsCaptured);
 
@@ -28,6 +30,8 @@ class Render {
 	void RenderFrame();
 
 	void PrepareToRendering();
+
+    void UpdateKeyboard();
 public:
 	Render(unsigned int windowWidth, unsigned int windowHeight, std::string windowTitle);
 	~Render();
diff --git a/src/Renderer.hpp b/src/Renderer.hpp
index 53f6cc8..306a310 100644
--- a/src/Renderer.hpp
+++ b/src/Renderer.hpp
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <GL/glew.h>
+#include "Utility.hpp"
 
 class RenderState {
 	GLuint ActiveVao = -1;
@@ -10,12 +11,4 @@ public:
 	void SetActiveShader(GLuint Shader);
     unsigned int WindowWidth, WindowHeight;
     long long TimeOfDay;
-};
-
-/*struct Renderer {
-    virtual ~Renderer() = default;
-    virtual void Render(RenderState& renderState) = 0;
-    virtual void PrepareResources() = 0;
-    virtual void PrepareRender() = 0;
-    virtual bool IsNeedResourcesPrepare() = 0;
-};*/
\ No newline at end of file
+};
\ No newline at end of file
diff --git a/src/RendererSection.cpp b/src/RendererSection.cpp
index 0965453..bb1a888 100644
--- a/src/RendererSection.cpp
+++ b/src/RendererSection.cpp
@@ -25,30 +25,18 @@ const GLfloat uv_coords[] = {
 const GLuint magicUniqueConstant = 88375;
 GLuint RendererSection::VboVertices = magicUniqueConstant;
 GLuint RendererSection::VboUvs = magicUniqueConstant;
-std::map<GLuint, int> RendererSection::refCounterVbo;
-std::map<GLuint, int> RendererSection::refCounterVao;
 
 RendererSection::~RendererSection() {
-	refCounterVbo[VboTextures]--;
-	refCounterVbo[VboModels]--;
-	refCounterVbo[VboColors]--;
-    refCounterVbo[VboLights]--;
-	refCounterVao[Vao]--;
-
-    if (refCounterVbo[VboTextures] <= 0)
-        glDeleteBuffers(1, &VboTextures);    
-
-	if (refCounterVbo[VboModels] <= 0)
-		glDeleteBuffers(1, &VboTextures);
-
-	if (refCounterVbo[VboColors] <= 0)
-		glDeleteBuffers(1, &VboColors);
-
-    if (refCounterVbo[VboLights] <= 0)
-        glDeleteBuffers(1, &VboLights);
+    if (Vao != 0)
+        glDeleteVertexArrays(1, &Vao);
+    
+    for (int i = 0; i < VBOCOUNT; i++)
+        if (Vbo[i] != 0) {
+            glBindBuffer(GL_ARRAY_BUFFER, Vbo[i]);
+            glBufferData(GL_ARRAY_BUFFER, 0, 0, GL_STATIC_DRAW);
+        }
 
-	if (refCounterVao[Vao] <= 0)
-		glDeleteVertexArrays(1, &Vao);
+    glDeleteBuffers(VBOCOUNT, Vbo);
 }
 
 void RendererSection::Render(RenderState &renderState) {
@@ -84,30 +72,9 @@ RendererSection::RendererSection(RendererSectionData data) {
             << ") for faces";
     }
 
-    glGenBuffers(1, &VboTextures);
-    if (refCounterVbo.find(VboTextures) == refCounterVbo.end())
-        refCounterVbo[VboTextures] = 0;
-    refCounterVbo[VboTextures]++;
-
-    glGenBuffers(1, &VboModels);
-    if (refCounterVbo.find(VboModels) == refCounterVbo.end())
-        refCounterVbo[VboModels] = 0;
-    refCounterVbo[VboModels]++;
-
-    glGenBuffers(1, &VboColors);
-    if (refCounterVbo.find(VboColors) == refCounterVbo.end())
-        refCounterVbo[VboColors] = 0;
-    refCounterVbo[VboColors]++;
-
-    glGenBuffers(1, &VboLights);
-    if (refCounterVbo.find(VboLights) == refCounterVbo.end())
-        refCounterVbo[VboLights] = 0;
-    refCounterVbo[VboLights]++;
-
     glGenVertexArrays(1, &Vao);
-    if (refCounterVao.find(Vao) == refCounterVao.end())
-        refCounterVao[Vao] = 0;
-    refCounterVao[Vao]++;
+
+    glGenBuffers(VBOCOUNT, Vbo);
 
     glBindVertexArray(Vao);
     {
@@ -125,7 +92,7 @@ RendererSection::RendererSection(RendererSectionData data) {
 
         //Textures
         GLuint textureAttribPos = 7;
-        glBindBuffer(GL_ARRAY_BUFFER, VboTextures);
+        glBindBuffer(GL_ARRAY_BUFFER, Vbo[TEXTURES]);
         glVertexAttribPointer(textureAttribPos, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), nullptr);
         glEnableVertexAttribArray(textureAttribPos);
         glVertexAttribDivisor(textureAttribPos, 1);
@@ -134,7 +101,7 @@ RendererSection::RendererSection(RendererSectionData data) {
         //Blocks models
         GLuint matAttribPos = 8;
         size_t sizeOfMat4 = 4 * 4 * sizeof(GLfloat);
-        glBindBuffer(GL_ARRAY_BUFFER, VboModels);
+        glBindBuffer(GL_ARRAY_BUFFER, Vbo[MODELS]);
         glVertexAttribPointer(matAttribPos + 0, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, nullptr);
         glVertexAttribPointer(matAttribPos + 1, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, (void *)(1 * 4 * sizeof(GLfloat)));
         glVertexAttribPointer(matAttribPos + 2, 4, GL_FLOAT, GL_FALSE, sizeOfMat4, (void *)(2 * 4 * sizeof(GLfloat)));
@@ -150,14 +117,14 @@ RendererSection::RendererSection(RendererSectionData data) {
 
         //Color
         GLuint colorAttribPos = 12;
-        glBindBuffer(GL_ARRAY_BUFFER, VboColors);
+        glBindBuffer(GL_ARRAY_BUFFER, Vbo[COLORS]);
         glVertexAttribPointer(colorAttribPos, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), nullptr);
         glEnableVertexAttribArray(colorAttribPos);
         glVertexAttribDivisor(colorAttribPos, 1);
 
         //Light
         GLuint lightAttribPos = 13;
-        glBindBuffer(GL_ARRAY_BUFFER, VboLights);
+        glBindBuffer(GL_ARRAY_BUFFER, Vbo[LIGHTS]);
         glVertexAttribPointer(lightAttribPos, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), nullptr);
         glEnableVertexAttribArray(lightAttribPos);
         glVertexAttribDivisor(lightAttribPos, 1);
@@ -169,16 +136,16 @@ RendererSection::RendererSection(RendererSectionData data) {
 
 
     //Upload data to VRAM
-    glBindBuffer(GL_ARRAY_BUFFER, VboTextures);
+    glBindBuffer(GL_ARRAY_BUFFER, Vbo[TEXTURES]);
     glBufferData(GL_ARRAY_BUFFER, data.textures.size() * sizeof(glm::vec4), data.textures.data(), GL_DYNAMIC_DRAW);
 
-    glBindBuffer(GL_ARRAY_BUFFER, VboModels);
+    glBindBuffer(GL_ARRAY_BUFFER, Vbo[MODELS]);
     glBufferData(GL_ARRAY_BUFFER, data.models.size() * sizeof(glm::mat4), data.models.data(), GL_DYNAMIC_DRAW);
 
-    glBindBuffer(GL_ARRAY_BUFFER, VboColors);
+    glBindBuffer(GL_ARRAY_BUFFER, Vbo[COLORS]);
     glBufferData(GL_ARRAY_BUFFER, data.colors.size() * sizeof(glm::vec3), data.colors.data(), GL_DYNAMIC_DRAW);
 
-    glBindBuffer(GL_ARRAY_BUFFER, VboLights);
+    glBindBuffer(GL_ARRAY_BUFFER, Vbo[LIGHTS]);
     glBufferData(GL_ARRAY_BUFFER, data.lights.size() * sizeof(glm::vec2), data.lights.data(), GL_DYNAMIC_DRAW);
 
     glBindBuffer(GL_ARRAY_BUFFER, 0);
@@ -188,21 +155,9 @@ RendererSection::RendererSection(RendererSectionData data) {
     hash = data.hash;
 }
 
-RendererSection::RendererSection(const RendererSection &other) {
-    this->VboModels = other.VboModels;
-    this->VboTextures = other.VboTextures;
-    this->VboColors = other.VboColors;
-    this->VboLights = other.VboLights;
-    this->sectionPos = other.sectionPos;
-    this->Vao = other.Vao;
-    this->numOfFaces = other.numOfFaces;
-    this->hash = other.hash;
-
-    refCounterVbo[VboTextures]++;
-    refCounterVbo[VboModels]++;
-    refCounterVbo[VboColors]++;
-    refCounterVbo[VboLights]++;
-    refCounterVao[Vao]++;
+RendererSection::RendererSection(RendererSection && other) {
+    using std::swap;
+    swap(*this, other);
 }
 
 RendererSectionData::RendererSectionData(World * world, Vector sectionPosition) {
@@ -214,7 +169,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
     for (int y = 0; y < 16; y++) {
         for (int z = 0; z < 16; z++) {
             for (int x = 0; x < 16; x++) {
-                Block block = section.GetBlock(Vector(x, y, z));
+                BlockId block = section.GetBlockId(Vector(x, y, z));
                 if (block.id == 0)
                     continue;
 
@@ -243,9 +198,9 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
                         if (std::find(sectionsList.begin(), sectionsList.end(), sectionPosition + offset) == sectionsList.end())
                             return true;
                         const Section& blockSection = world->GetSection(sectionPosition + offset);
-                        return blockSection.GetBlock(block).id == 0 || blockSection.GetBlock(block).id == 31 || blockSection.GetBlock(block).id == 18;
+                        return blockSection.GetBlockId(block).id == 0 || blockSection.GetBlockId(block).id == 31 || blockSection.GetBlockId(block).id == 18;
                     }                    
-                    return  section.GetBlock(block).id == 0 || section.GetBlock(block).id == 31 || section.GetBlock(block).id == 18;
+                    return  section.GetBlockId(block).id == 0 || section.GetBlockId(block).id == 31 || section.GetBlockId(block).id == 18;
                 };
 
                 unsigned char isVisible = 0;
@@ -272,7 +227,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
                     for (int i = 0; i < 4; i++) {
                         textures.push_back(texture->second);
                         colors.push_back(color);
-                        lights.push_back(glm::vec2(block.light, block.sky));
+                        lights.push_back(glm::vec2(0, 0));
                     }
                     glm::mat4 faceTransform = glm::translate(transform, glm::vec3(0.15f, 0, 0.15f));
                     faceTransform = glm::scale(faceTransform, glm::vec3(1.0f, 0.9f, 1.0f));
@@ -298,7 +253,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
                         textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
                             0.0078125, 0.00442477876106194690)); //Fallback TNT texture
                     colors.push_back(color);
-                    lights.push_back(glm::vec2(block.light, block.sky));
+                    lights.push_back(glm::vec2(0, 0));
                 }
                 if (isVisible >> 1 & 0x1) { //west side X-
                     glm::mat4 faceTransform = glm::translate(transform, glm::vec3(1, 0, 0));
@@ -313,7 +268,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
                         textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
                             0.0078125, 0.00442477876106194690)); //Fallback TNT texture
                     colors.push_back(color);
-                    lights.push_back(glm::vec2(block.light, block.sky));
+                    lights.push_back(glm::vec2(0, 0));
                 }
                 if (isVisible >> 2 & 0x1) { //Top side Y+
                     glm::mat4 faceTransform = glm::translate(transform, glm::vec3(0, 1, 0));
@@ -328,7 +283,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
                         colors.push_back(color);
                     else
                         colors.push_back(biomeColor);
-                    lights.push_back(glm::vec2(block.light, block.sky));
+                    lights.push_back(glm::vec2(0, 0));
                 }
                 if (isVisible >> 3 & 0x1) { //Bottom side Y-
                     glm::mat4 faceTransform = glm::translate(transform, glm::vec3(0, 0, 0));
@@ -342,7 +297,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
                         textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
                             0.0078125, 0.00442477876106194690)); //Fallback TNT texture
                     colors.push_back(color);
-                    lights.push_back(glm::vec2(block.light, block.sky));
+                    lights.push_back(glm::vec2(0, 0));
                 }
                 if (isVisible >> 4 & 0x1) { //south side Z+
                     glm::mat4 faceTransform = glm::translate(transform, glm::vec3(1, 0, 0));
@@ -356,7 +311,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
                         textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
                             0.0078125, 0.00442477876106194690)); //Fallback TNT texture
                     colors.push_back(color);
-                    lights.push_back(glm::vec2(block.light, block.sky));
+                    lights.push_back(glm::vec2(0, 0));
                 }
                 if (isVisible >> 5 & 0x1) { //north side Z-
                     glm::mat4 faceTransform = glm::translate(transform, glm::vec3(0, 0, 1));
@@ -373,7 +328,7 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
                         textures.push_back(glm::vec4(0.0546875, 0.00442477876106194690,
                             0.0078125, 0.00442477876106194690)); //Fallback TNT texture
                     colors.push_back(color);
-                    lights.push_back(glm::vec2(block.light, block.sky));
+                    lights.push_back(glm::vec2(0, 0));
                 }
             }
         }
@@ -383,9 +338,12 @@ RendererSectionData::RendererSectionData(World * world, Vector sectionPosition)
     textures.shrink_to_fit();
     models.shrink_to_fit();
     colors.shrink_to_fit();
+}
 
-    /*for (auto& it : lights) {
-        it.x = 8;
-        it.y = 16;
-    }*/
+void swap(RendererSection & lhs, RendererSection & rhs) {
+    std::swap(lhs.Vbo, rhs.Vbo);
+    std::swap(lhs.Vao, rhs.Vao);
+    std::swap(lhs.hash, rhs.hash);
+    std::swap(lhs.numOfFaces, rhs.numOfFaces);
+    std::swap(lhs.sectionPos, rhs.sectionPos);
 }
diff --git a/src/RendererSection.hpp b/src/RendererSection.hpp
index 9e5fd99..12a169e 100644
--- a/src/RendererSection.hpp
+++ b/src/RendererSection.hpp
@@ -23,19 +23,28 @@ struct RendererSectionData {
 
     RendererSectionData(World *world, Vector sectionPosition);
 };
-
 class RendererSection {
-	GLuint Vao, VboTextures, VboModels, VboColors, VboLights;
+    enum Vbos {
+        MODELS = 0,
+        TEXTURES,
+        COLORS,
+        LIGHTS,
+        VBOCOUNT,
+    };
+    GLuint Vao = { 0 };
+    GLuint Vbo[VBOCOUNT] = { 0 };
 	
 	static GLuint VboVertices, VboUvs;
-	static std::map<GLuint, int> refCounterVbo;
-	static std::map<GLuint, int> refCounterVao;
 
 	size_t hash;
     Vector sectionPos;
+
+    RendererSection(const RendererSection &other) = delete;
 public:
     RendererSection(RendererSectionData data);
-	RendererSection(const RendererSection &other);
+
+    RendererSection(RendererSection &&other);
+
 	~RendererSection();
 
 	void Render(RenderState &renderState);
@@ -44,5 +53,7 @@ public:
 
     size_t GetHash();
 
-    size_t numOfFaces = 0;
+    size_t numOfFaces;
+
+    friend void swap(RendererSection &lhs, RendererSection &rhs);
 };
\ No newline at end of file
diff --git a/src/RendererWidget.cpp b/src/RendererWidget.cpp
new file mode 100644
index 0000000..6b732e3
--- /dev/null
+++ b/src/RendererWidget.cpp
@@ -0,0 +1,76 @@
+#include "RendererWidget.hpp"
+
+const GLfloat vertices[] = {
+    0.0f,0.0f,0.0f,    
+    1.0f,1.0f,0.0f,
+    0.0f,1.0f,0.0f,
+
+    0.0f,0.0f,0.0f,
+    1.0f,0.0f,0.0f,
+    1.0f,1.0f,0.0f,
+};
+
+const GLfloat uvs[] = {
+    0.0f,0.0f,
+    1.0f,1.0f,
+    0.0f,1.0f,    
+
+    0.0f,0.0f,    
+    1.0f,0.0f,
+    1.0f,1.0f,
+};
+
+static GLuint VboVertices, VboUvs, Vao;
+static Shader* guiShader = nullptr;
+
+RendererWidget::RendererWidget(RootWidget *widget) {
+    this->tree = widget;
+
+    if (guiShader == nullptr) {
+        guiShader = new Shader("./shaders/gui.vs", "./shaders/gui.fs");
+        guiShader->Use();
+        glUniform1i(glGetUniformLocation(guiShader->Program, "textureAtlas"), 0);        
+        
+        glGenBuffers(1, &VboVertices);
+        glBindBuffer(GL_ARRAY_BUFFER, VboVertices);
+        glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+        glGenBuffers(1, &VboUvs);
+        glBindBuffer(GL_ARRAY_BUFFER, VboUvs);
+        glBufferData(GL_ARRAY_BUFFER, sizeof(uvs), uvs, GL_STATIC_DRAW);
+
+        glGenVertexArrays(1, &Vao);
+        glBindVertexArray(Vao);
+        {
+            glBindBuffer(GL_ARRAY_BUFFER, VboVertices);
+            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0);
+            glEnableVertexAttribArray(0);
+
+            glBindBuffer(GL_ARRAY_BUFFER, VboUvs);
+            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (GLvoid*)0);
+            glEnableVertexAttribArray(1);
+        }
+        glBindVertexArray(0);
+    }
+}
+
+RendererWidget::~RendererWidget() {
+
+}
+
+void RendererWidget::Render(RenderState &state) {
+    state.SetActiveVao(Vao);
+    state.SetActiveShader(guiShader->Program);
+
+    auto toRender = tree->GetRenderList();
+    for (auto& it : toRender) {
+        auto[x, y, w, h] = it->GetTexture();
+        glUniform4f(glGetUniformLocation(guiShader->Program, "widgetTexture"), x, y, w, h);
+
+        glUniform4f(glGetUniformLocation(guiShader->Program, "transform"), it->x, it->y, it->w, it->h);
+
+        glDrawArrays(GL_TRIANGLES, 0, 36);
+    }
+
+    glCheckError();
+}
\ No newline at end of file
diff --git a/src/RendererWidget.hpp b/src/RendererWidget.hpp
new file mode 100644
index 0000000..a979c88
--- /dev/null
+++ b/src/RendererWidget.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include "Renderer.hpp"
+#include "Widget.hpp"
+#include "Shader.hpp"
+
+class RendererWidget {
+    RootWidget *tree;
+    
+public:
+    RendererWidget(RootWidget *widget);
+    ~RendererWidget();
+
+    void Render(RenderState &state);
+};
\ No newline at end of file
diff --git a/src/RendererWorld.cpp b/src/RendererWorld.cpp
index dd5fdb4..7262583 100644
--- a/src/RendererWorld.cpp
+++ b/src/RendererWorld.cpp
@@ -94,7 +94,6 @@ RendererWorld::RendererWorld(std::shared_ptr<GameState> ptr):gs(ptr) {
         sectionsMutex.lock();
         auto it = sections.find(vec);
         if (it == sections.end()) {
-            //LOG(ERROR) << "Deleting wrong sectionRenderer";
             sectionsMutex.unlock();
             return;
         }
@@ -124,7 +123,7 @@ RendererWorld::RendererWorld(std::shared_ptr<GameState> ptr):gs(ptr) {
                 sections.erase(sections.find(data.sectionPos));
             }
             RendererSection renderer(data);
-            sections.insert(std::make_pair(data.sectionPos, renderer));
+            sections.insert(std::make_pair(data.sectionPos, std::move(renderer)));
             sectionsMutex.unlock();
             renderData.pop();
         }
@@ -155,7 +154,6 @@ RendererWorld::RendererWorld(std::shared_ptr<GameState> ptr):gs(ptr) {
         if (isParsing.find(vec) == isParsing.end())
             isParsing[vec] = false;
         if (isParsing[vec] == true) {
-            //LOG(WARNING) << "Changed parsing block";
             isParsingMutex.unlock();
             return;
         }
@@ -188,6 +186,8 @@ RendererWorld::RendererWorld(std::shared_ptr<GameState> ptr):gs(ptr) {
     for (int i = 0; i < numOfWorkers; i++)
         workers.push_back(std::thread(&RendererWorld::WorkerFunction, this, i));
 
+    EventAgregator::PushEvent(EventType::UpdateSectionsRender, UpdateSectionsRenderData{});
+
     //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
 }
 
@@ -349,7 +349,7 @@ void RendererWorld::PrepareRender() {
 }
 
 void RendererWorld::Update(double timeToUpdate) {
-    auto timeSincePreviousUpdate = std::chrono::steady_clock::now();
+    static auto timeSincePreviousUpdate = std::chrono::steady_clock::now();
     int i = 0;
     while (listener.IsEventsQueueIsNotEmpty() && i++ < 50)
         listener.HandleEvent();
diff --git a/src/RendererWorld.hpp b/src/RendererWorld.hpp
index 5bc575c..4e098e5 100644
--- a/src/RendererWorld.hpp
+++ b/src/RendererWorld.hpp
@@ -37,9 +37,7 @@ public:
 	~RendererWorld();
 
     void Render(RenderState& renderState);
-    void PrepareResources();
     void PrepareRender();
-    bool IsNeedResourcesPrepare();
 
     double MaxRenderingDistance;
 
diff --git a/src/Section.cpp b/src/Section.cpp
index c9af5c6..9b4292b 100644
--- a/src/Section.cpp
+++ b/src/Section.cpp
@@ -2,164 +2,134 @@
 
 #include <bitset>
 
+void Section::CalculateHash() {
+    std::vector<unsigned char> rawData;
+    rawData.reserve(block.size() * sizeof(long long) + light.size() + sky.size());
+    std::copy(block.begin(), block.end(), std::back_inserter(rawData));
+    std::copy(light.begin(), light.end(), std::back_inserter(rawData));
+    if (!sky.empty())
+        std::copy(sky.begin(), sky.end(), std::back_inserter(rawData));
+
+    const unsigned char *from = reinterpret_cast<const unsigned char *>(rawData.data());
+    size_t length = rawData.size();
+
+    std::string str(from, from + length);
+    hash =  std::hash<std::string>{}(str);
+}
+
+Section::Section(Vector pos, unsigned char bitsPerBlock, std::vector<unsigned short> palette, std::vector<long long> blockData, std::vector<unsigned char> lightData, std::vector<unsigned char> skyData) {
+    if (bitsPerBlock < 4)
+        bitsPerBlock = 4;
+    if (bitsPerBlock > 8)
+        bitsPerBlock = 13;
+    this->bitsPerBlock = bitsPerBlock;
+
+    this->worldPosition = pos;
+    this->block = std::move(blockData);
+    this->palette = std::move(palette);
+    this->light = std::move(lightData);
+    this->sky = std::move(skyData);
+
+    CalculateHash();
+}
+
+Section::Section() {
+
+    CalculateHash();    
+}
+
 Section::~Section() {
+
 }
 
 Section::Section(Section && other) noexcept {
     using std::swap;
     swap(*this, other);
+    CalculateHash();
 }
 
-Block &Section::GetBlock(Vector pos) {
-	return blocks[pos.y * 256 + pos.z * 16 + pos.x];
+Section &Section::operator=(Section other) noexcept {
+    using std::swap;
+	swap(*this, other);
+    CalculateHash();
+	return *this;
 }
 
-Block Section::GetBlock(Vector pos) const
-{
-    if (blocks.empty()) {
-        static Block fallback;
-        return fallback;
+BlockId Section::GetBlockId(Vector pos) const {
+    if (block.empty())
+        return BlockId{ 0,0 };
+    int value;
+
+    unsigned char individualValueMask = ((1 << bitsPerBlock) - 1);
+
+    int blockNumber = (((pos.y * 16) + pos.z) * 16) + pos.x;
+    int startLong = (blockNumber * bitsPerBlock) / 64;
+    int startOffset = (blockNumber * bitsPerBlock) % 64;
+    int endLong = ((blockNumber + 1) * bitsPerBlock - 1) / 64;
+
+    unsigned short t;
+
+    if (startLong == endLong) {
+        t = (block[startLong] >> startOffset);
+    }
+    else {
+        int endOffset = 64 - startOffset;
+        t = (block[startLong] >> startOffset |block[endLong] << endOffset);
     }
-    return blocks[pos.y * 256 + pos.z * 16 + pos.x];
+
+    t &= individualValueMask;
+
+
+    if (t >= palette.size()) {
+        //LOG(ERROR) << "Out of palette: " << t;
+        value = 0;
+    }
+    else
+        value = palette[t];
+
+    BlockId blockId;
+    blockId.id = value >> 4;
+    blockId.state = value & 0xF;    
+    return blockId;
 }
 
-double totalParsingTime = 0;
+unsigned char Section::GetBlockLight(Vector pos)
+{
+    int blockNumber = pos.y * 256 + pos.z * 16 + pos.x;
+    unsigned char lightValue = this->light[blockNumber];
+    return (blockNumber % 2 == 0) ? (lightValue & 0xF) : (lightValue >> 4);
+}
 
-Section::Section(PackedSection data)
+unsigned char Section::GetBlockSkyLight(Vector pos)
 {
-    if (data.blocks.empty())
-        return;
-    worldPosition = data.position;
-
-    bool useFirst = false;
-
-    if (useFirst) {
-        unsigned char *blocksData = reinterpret_cast<unsigned char*>(data.blocks.data());
-        std::vector<unsigned short> blocks;
-        blocks.reserve(4096);
-        {
-            auto begin = std::chrono::steady_clock::now();
-            int bitPos = 0;
-            unsigned short t = 0;
-            for (size_t i = 0; i < data.blocks.size() * 8; i++) {
-                for (int j = 0; j < 8; j++) {
-                    t |= (blocksData[i] & 0x01) ? 0x80 : 0x00;
-                    t >>= 1;
-                    blocksData[i] >>= 1;
-                    bitPos++;
-                    if (bitPos >= data.bitsPerBlock) {
-                        bitPos = 0;
-                        t >>= data.bitsPerBlock - 1;
-                        blocks.push_back(t);
-                        t = 0;
-                    }
-                }
-            }
-            auto end = std::chrono::steady_clock::now();
-            std::chrono::duration<double, std::milli> time = end - begin;
-            totalParsingTime += time.count();
-        }
-        std::vector<byte> light;
-        light.reserve(4096);
-        for (int i = 0; i < 2048; i++) {
-            byte t = data.light[i];
-            byte first = t & 0x0F;
-            byte second = t >> 4;
-            light.push_back(0);
-            light.push_back(0);
-        }
-
-        std::vector<byte> sky;
-        if (!data.sky.empty()) {
-            sky.reserve(4096);
-            for (int i = 0; i < 2048; i++) {
-                byte t = data.sky[i];
-                byte first = t & 0x0F;
-                byte second = t >> 4;
-                sky.push_back(first);
-                sky.push_back(second);
-            }
-        }
-
-        for (int i = 0; i < 4096; i++) {
-            unsigned short blockId = !data.palette.empty() ? data.palette[blocks[i]] : blocks[i];
-            Block block(blockId >> 4, blockId & 0xF, light[i], sky.empty() ? 0 : sky[i]);
-            this->blocks.push_back(block);
-        }
-    } else {
-
-        std::vector<unsigned short> blocks;
-        blocks.reserve(4096);
-
-        unsigned char individualValueMask = ((1 << data.bitsPerBlock) - 1);
-
-        for (int blockNumber = 0; blockNumber < 4096; blockNumber++) {
-            int startLong = (blockNumber * data.bitsPerBlock) / 64;
-            int startOffset = (blockNumber * data.bitsPerBlock) % 64;
-            int endLong = ((blockNumber + 1) * data.bitsPerBlock - 1) / 64;
-
-            unsigned short t;
-
-            if (startLong == endLong) {
-                t = (data.blocks[startLong] >> startOffset);
-            }
-            else {
-                int endOffset = 64 - startOffset;
-                t = (data.blocks[startLong] >> startOffset | data.blocks[endLong] << endOffset);
-            }
-
-            t &= individualValueMask;
-
-
-            if (t >= data.palette.size()) {
-                //LOG(ERROR) << "Out of palette: "<<t;
-                blocks.push_back(0);
-            }
-            else
-                blocks.push_back(data.palette.empty() ? t : data.palette[t]);
-        }
-
-
-        std::vector<unsigned char> light;
-        light.reserve(4096);
-        for (int i = 0; i < 2048; i++) {
-            unsigned char t = data.light[i];
-            light.push_back(t & 0xF);
-            light.push_back(t >> 4 & 0xF);
-        }
-
-        std::vector<unsigned char> sky;
-        if (!data.sky.empty()) {
-            sky.reserve(4096);
-            for (int i = 0; i < 2048; i++) {
-                unsigned char t = data.sky[i];
-                sky.push_back(t & 0xF);
-                sky.push_back(t >> 4 & 0xF);
-            }
-        }
-
-        for (int i = 0; i < 4096; i++) {
-            unsigned short blockId = blocks[i];
-            Block block(blockId >> 4, blockId & 0xF, light[i], sky.empty() ? 0 : sky[i]);
-            this->blocks.push_back(block);
-        }
-    }
+    int blockNumber = pos.y * 256 + pos.z * 16 + pos.x;
+    unsigned char skyValue = this->sky[blockNumber];
+    return (blockNumber % 2 == 0) ? (skyValue & 0xF) : (skyValue >> 4);
 }
 
-Section &Section::operator=(Section other) noexcept {
-    using std::swap;
-	swap(*this, other);
-	return *this;
+void Section::SetBlockId(Vector pos, BlockId value) {
+    LOG(WARNING) << "Block changing not implemented!";
 }
 
 void swap(Section& lhs, Section& rhs) noexcept {
-    std::swap(lhs.blocks, rhs.blocks);
+    std::swap(lhs.block, rhs.block);
+    std::swap(lhs.light, rhs.light);
+    std::swap(lhs.sky, rhs.sky);
+    std::swap(lhs.bitsPerBlock, rhs.bitsPerBlock);
+    std::swap(lhs.palette, rhs.palette);
+    std::swap(lhs.hash, rhs.hash);
     std::swap(lhs.worldPosition, rhs.worldPosition);
 }
 
 Section::Section(const Section &other) {
 	worldPosition = other.worldPosition;	
-    this->blocks = other.blocks;
+    this->block = other.block;
+    this->light = other.light;
+    this->sky = other.sky;
+    this->bitsPerBlock = other.bitsPerBlock;
+    this->palette = other.palette;
+    this->hash = other.hash;
+    this->worldPosition = other.worldPosition;
 }
 
 Vector Section::GetPosition() const {
@@ -167,32 +137,5 @@ Vector Section::GetPosition() const {
 }
 
 size_t Section::GetHash() const {
-	if (blocks.empty()) return 0;
-
-	const unsigned char *from = reinterpret_cast<const unsigned char *>(blocks.data());
-	size_t length = blocks.size() * sizeof(Block);
-
-	std::string str(from, from + length);
-	return std::hash<std::string>{}(str);
-}
-
-PackedSection::PackedSection(Vector position, byte * dataBlocks, size_t dataBlocksLength, byte * dataLight, byte * dataSky, byte bitsPerBlock, std::vector<unsigned short> palette)
-{
-    this->position = position;
-
-    this->palette = palette;
-
-    this->bitsPerBlock = bitsPerBlock;
-
-    for (long long *t = reinterpret_cast<long long *>(dataBlocks); (byte*)t < dataBlocks + dataBlocksLength; t++) {
-        long long l = *t;
-        endswap(l);
-        this->blocks.push_back(l);
-    }
-
-    light.assign(dataLight, dataLight + 2048);
-
-    if (dataSky != nullptr) {
-        sky.assign(dataSky, dataSky + 2048);
-    }
-}
+    return hash;
+}
\ No newline at end of file
diff --git a/src/Section.hpp b/src/Section.hpp
index dfa738a..bda3584 100644
--- a/src/Section.hpp
+++ b/src/Section.hpp
@@ -11,47 +11,45 @@
 #include "Vector.hpp"
 #include "Utility.hpp"
 
-struct PackedSection {
-    Vector position;
-
-    int bitsPerBlock;
-
-    std::vector<unsigned short> palette;
-
-    std::vector<long long> blocks;
+class Section {
+    std::vector<long long> block;
     std::vector<unsigned char> light;
     std::vector<unsigned char> sky;
-
-    PackedSection(Vector position, byte *dataBlocks, size_t dataBlocksLength, byte *dataLight, byte *dataSky, byte bitsPerBlock,
-        std::vector<unsigned short> palette);
-
-    PackedSection() = default;
-};
-
-class Section {
-	std::vector<Block> blocks;
+    unsigned char bitsPerBlock;
+    std::vector<unsigned short> palette;
 
 	Vector worldPosition;
+    size_t hash;
 
+    void CalculateHash();
 public:
+    Section(Vector pos, unsigned char bitsPerBlock, std::vector<unsigned short> palette, std::vector<long long> blockData, std::vector<unsigned char> lightData, std::vector<unsigned char> skyData);
     
-    Section(PackedSection data);
+    Section();
 
 	~Section();
 
+    Section(const Section &other);
+
     Section(Section &&other) noexcept;
 
-	Block &GetBlock(Vector pos);
+	Section &operator=(Section other) noexcept;
 
-    Block GetBlock(Vector pos) const;
+    BlockId GetBlockId(Vector pos) const;
 
-	Section &operator=(Section other) noexcept;
+    unsigned char GetBlockLight(Vector pos);
 
-    friend void swap(Section& lhs, Section& rhs) noexcept;
+    unsigned char GetBlockSkyLight(Vector pos);
 
-	Section(const Section &other);
+    void SetBlockId(Vector pos, BlockId value);
+
+    void SetBlockLight(Vector pos, unsigned char value);
+
+    void SetBlockSkyLight(Vector pos, unsigned char value);
 
 	Vector GetPosition() const;
 
     size_t GetHash() const;
+
+    friend void swap(Section& lhs, Section& rhs) noexcept;
 };
\ No newline at end of file
diff --git a/src/Socket.cpp b/src/Socket.cpp
index 519da2f..aea0c73 100644
--- a/src/Socket.cpp
+++ b/src/Socket.cpp
@@ -1,30 +1,37 @@
 #include <iostream>
 #include "Socket.hpp"
 
-Socket::Socket(std::string address, unsigned short port) {
-	sf::Socket::Status connectionStatus = socket.connect(sf::IpAddress(address), port);
-	if (connectionStatus == sf::Socket::Status::Error)
-		throw std::runtime_error("Can't connect to remote server");
-	else if (connectionStatus != sf::Socket::Status::Done)
-		throw std::runtime_error("Connection failed with unknown reason");
+#include <thread>
+
+Socket::Socket(std::string address, unsigned short port) {    
+    if (SDLNet_Init() == -1)
+        throw std::runtime_error("SDL_Net initalization failed: " + std::string(SDLNet_GetError()));
+
+    if (SDLNet_ResolveHost(&server, address.c_str(), port) == -1)
+        throw std::runtime_error("Hostname not resolved: " + std::string(SDLNet_GetError()));
+
+    socket = SDLNet_TCP_Open(&server);
+    if (!socket)
+        throw std::runtime_error(std::string(SDLNet_GetError()));
 }
 
 Socket::~Socket() {
-	socket.disconnect();
+    SDLNet_TCP_Close(socket);
+
+    SDLNet_Quit();
 }
 
-void Socket::Read(unsigned char *buffPtr, size_t buffLen) {
-	size_t received = 0;
-	socket.receive(buffPtr, buffLen, received);
-	size_t totalReceived = received;
-	while (totalReceived < buffLen) {
-		if (socket.receive(buffPtr + totalReceived, buffLen - totalReceived, received) != sf::Socket::Done)
-			throw std::runtime_error("Raw socket data receiving is failed");
-		totalReceived += received;
-	}
+void Socket::Read(unsigned char *buffPtr, size_t buffLen) {    
+    size_t totalReceived = 0;
+    while (buffLen > totalReceived) {
+        size_t received = SDLNet_TCP_Recv(socket, buffPtr + totalReceived, buffLen - totalReceived);
+        if ( received <= 0)
+            throw std::runtime_error("Data receiving failed: " + std::string(SDLNet_GetError()));
+        totalReceived += received;
+    }
 }
 
 void Socket::Write(unsigned char *buffPtr, size_t buffLen) {
-	if (socket.send(buffPtr, buffLen) != sf::Socket::Done)
-		throw std::runtime_error("Raw socket data sending is failed");
+    if (SDLNet_TCP_Send(socket, buffPtr, buffLen) < buffLen)
+        throw std::runtime_error("Data sending failed: " + std::string(SDLNet_GetError()));
 }
diff --git a/src/Socket.hpp b/src/Socket.hpp
index 48bcad9..16825f0 100644
--- a/src/Socket.hpp
+++ b/src/Socket.hpp
@@ -4,14 +4,16 @@
 
 #include <SFML/Network.hpp>
 
+#include <SDL_net.h>
+
 /**
  * Platform independent class for working with platform dependent hardware socket
  * @brief Wrapper around raw sockets
  * @warning Connection state is based on lifetime of Socket object instance, ie connected at ctor and disconnect at dtor
- * @todo Replace SFML's socket with  WinSock and POSIX's socket implementation
  */
 class Socket {
-	sf::TcpSocket socket;
+    IPaddress server;
+    TCPsocket socket;
 public:
 	/**
 	 * Constructs Socket class instance from IP's string and Port number and connects to remote server
@@ -23,7 +25,7 @@ public:
 
 	/**
 	 * Destruct Socket instance and disconnect from server
-	 * @warning There is no way to force disconnect, except use delete for manually allocated objects and scope of visibility for variables on stack
+	 * @warning There is no way to force disconnect, except use delete for manually allocated objects and scope of visibility for auto variables
 	 */
 	~Socket();
 
diff --git a/src/Stream.cpp b/src/Stream.cpp
index a44b91c..28680c6 100644
--- a/src/Stream.cpp
+++ b/src/Stream.cpp
@@ -281,8 +281,9 @@ void StreamOutput::WriteByteArray(std::vector<unsigned char> value) {
 
 void StreamBuffer::ReadData(unsigned char *buffPtr, size_t buffLen) {
 	size_t bufferLengthLeft = buffer + bufferLength - bufferPtr;
+
     if (bufferLengthLeft < buffLen)
-        throw std::runtime_error("Required data is more, than in buffer available");
+        throw std::runtime_error("Internal error: StreamBuffer reader out of data");
 	std::memcpy(buffPtr, bufferPtr, buffLen);
 	bufferPtr += buffLen;
 }
@@ -290,7 +291,7 @@ void StreamBuffer::ReadData(unsigned char *buffPtr, size_t buffLen) {
 void StreamBuffer::WriteData(unsigned char *buffPtr, size_t buffLen) {
 	size_t bufferLengthLeft = buffer + bufferLength - bufferPtr;
 	if (bufferLengthLeft < buffLen)
-		throw std::runtime_error("Required data is more, than in buffer available");
+		throw std::runtime_error("Internal error: StreamBuffer writer out of data");
 	std::memcpy(bufferPtr, buffPtr, buffLen);
 	bufferPtr += buffLen;
 }
diff --git a/src/Widget.cpp b/src/Widget.cpp
new file mode 100644
index 0000000..1a522ca
--- /dev/null
+++ b/src/Widget.cpp
@@ -0,0 +1,124 @@
+#include "Widget.hpp"
+
+void RootWidget::AttachWidget(std::unique_ptr<Widget> widget, Widget * parent)
+{
+    parent->childs.push_back(widget.get());
+    this->allWidgets.push_back(std::move(widget));
+}
+
+void RootWidget::AttachWidget(std::unique_ptr<Widget> widget) {
+    widget->parent = nullptr;
+    this->childs.push_back(widget.get());
+    this->allWidgets.push_back(std::move(widget));
+}
+
+std::vector<Widget*> RootWidget::GetRenderList()
+{
+    std::vector<Widget*> renderList;    
+
+    std::function<void(Widget*)> treeWalker = [&](Widget* node) {
+        for (auto it : node->childs)
+            treeWalker(it);
+        renderList.push_back(node);
+    };
+
+    for (auto& it : this->childs)
+        treeWalker(it);
+
+    return renderList;
+}
+
+void RootWidget::UpdateEvents(double mouseX, double mouseY, bool mouseButton) {
+
+    LOG(INFO) << mouseX << "x" << mouseY;
+
+    auto testIsHover = [&](double x, double y, Widget* widget) {
+        bool isOnX = widget->x > x && widget->x + widget->w < x;
+        bool isOnY = widget->y > y && widget->y + widget->h < y;
+        if (mouseButton)
+            LOG(INFO) << "X: " << isOnX << " Y: " << isOnY;
+        return isOnX && isOnY;
+    };
+
+    std::function<void(Widget*)> treeWalker = [&](Widget* node) {
+        for (auto it : node->childs)
+            treeWalker(it);
+        
+        if (testIsHover(mouseX,mouseY,node)) {
+            if (node->onHover)
+                node->onHover(node);
+            if (mouseButton && !prevBut)
+                if (node->onPress)
+                    node->onPress(node);
+            else if (!mouseButton && prevBut)
+                if (node->onRelease)
+                    node->onRelease(node);
+        }
+        else {
+            if (testIsHover(prevX, prevY, node))
+                if (node->onUnhover)
+                    node->onUnhover(node);
+        }
+        
+        if (node->onUpdate)
+            node->onUpdate(node);
+    };
+
+    for (auto it : childs)
+        treeWalker(it);
+
+    prevX = mouseX;
+    prevY = mouseY;
+    prevBut = mouseButton;
+}
+
+WidgetButton::WidgetButton()
+{
+    this->state = WidgetState::Idle;
+
+    onHover = [](Widget* widget) {
+        WidgetButton* w = dynamic_cast<WidgetButton*>(widget);
+        if (w->state != WidgetState::Pressed)
+            w->state = WidgetState::Hovering;
+        LOG(INFO) << "Hover";
+    };
+
+    onPress = [](Widget* widget) {
+        WidgetButton* w = dynamic_cast<WidgetButton*>(widget);
+        w->state = WidgetState::Pressed;
+        LOG(INFO) << "Press";
+    };
+
+    onRelease = [](Widget* widget) {
+        WidgetButton* w = dynamic_cast<WidgetButton*>(widget);
+        w->state = WidgetState::Idle;
+        w->onClick(w);
+        LOG(INFO) << "Release";
+    };
+
+    onUnhover = [](Widget *widget) {
+        WidgetButton* w = dynamic_cast<WidgetButton*>(widget);
+        if (w->state!=WidgetState::Pressed)
+            w->state = WidgetState::Idle;
+        LOG(INFO) << "Unhover";
+    };
+
+}
+
+std::tuple<double, double, double, double> WidgetButton::GetTexture()
+{
+    double yOffset;
+    switch (this->state) {
+    case WidgetState::Idle:
+        yOffset = 0.2578;
+        break;
+    case WidgetState::Hovering:
+        yOffset = 0.3359;
+        break;
+    case WidgetState::Pressed:
+        yOffset = 0.1796;
+    }
+
+    TextureCoordinates texture = AssetManager::Instance().GetTextureByAssetName("minecraft/textures/gui/widgets");
+    return { texture.x,texture.y + texture.h * yOffset,texture.w * 0.7812,texture.h * 0.07812 };
+}
diff --git a/src/Widget.hpp b/src/Widget.hpp
new file mode 100644
index 0000000..6d78ebe
--- /dev/null
+++ b/src/Widget.hpp
@@ -0,0 +1,74 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <functional>
+
+#include "AssetManager.hpp"
+
+class Widget;
+class RootWidget {
+    std::vector<std::unique_ptr<Widget>> allWidgets;
+
+    std::vector<Widget*> childs;
+
+    double prevX, prevY;
+    bool prevBut;
+public:
+    RootWidget() = default;
+
+    ~RootWidget() = default;
+
+    void AttachWidget(std::unique_ptr<Widget> widget, Widget* parent);
+
+    void AttachWidget(std::unique_ptr<Widget> widget);
+
+    std::vector<Widget*> GetRenderList();
+
+    void UpdateEvents(double mouseX, double mouseY, bool mouseButton);
+};
+
+struct Widget {
+    Widget() = default;
+
+    virtual ~Widget() = default;
+
+    Widget *parent;
+
+    std::vector<Widget*> childs;
+
+    double x, y, w, h; //In OGL screen-coordinates
+
+    virtual std::tuple<double, double, double, double> GetTexture() = 0;
+
+    
+    using Handler = std::function<void(Widget*)>;
+
+    Handler onPress;
+
+    Handler onRelease;
+
+    Handler onHover;
+
+    Handler onUnhover;
+
+    Handler onUpdate;
+};
+
+struct WidgetButton : Widget {
+    WidgetButton();
+
+    ~WidgetButton() override = default;
+
+    std::string Text;
+
+    Handler onClick;
+
+    std::tuple<double, double, double, double> GetTexture() override;
+
+    enum class WidgetState {
+        Idle,
+        Hovering,
+        Pressed,
+    } state;
+};
\ No newline at end of file
diff --git a/src/World.cpp b/src/World.cpp
index f9edbe1..1a0e0fa 100644
--- a/src/World.cpp
+++ b/src/World.cpp
@@ -7,29 +7,23 @@ void World::ParseChunkData(std::shared_ptr<PacketChunkData> packet) {
 	for (int i = 0; i < 16; i++) {
 		if (bitmask[i]) {
 			Vector chunkPosition = Vector(packet->ChunkX, i, packet->ChunkZ);
-			PackedSection packedSection = ParseSection(&chunkData, chunkPosition);
-            Section section(packedSection);
+			Section section = ParseSection(&chunkData, chunkPosition);
             
             if (packet->GroundUpContinuous) {
-                if (!cachedSections.insert(std::make_pair(chunkPosition, section)).second) {
+                if (!sections.insert(std::make_pair(chunkPosition, section)).second) {
                     LOG(ERROR) << "New chunk not created " << chunkPosition << " potential memory leak";
                 }
             } else {
                 using std::swap;
-                swap(cachedSections.at(chunkPosition), section);                
+                swap(sections.at(chunkPosition), section);                
             }
             EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ chunkPosition });
         }
 	}
 }
 
-PackedSection World::ParseSection(StreamInput *data, Vector position) {
-	unsigned char bitsPerBlock = data->ReadUByte();
-    if (bitsPerBlock < 4)
-        bitsPerBlock = 4;
-
-    if (bitsPerBlock > 8)
-        bitsPerBlock = 13;
+Section World::ParseSection(StreamInput *data, Vector position) {
+	unsigned char bitsPerBlock = data->ReadUByte();    
 
 	int paletteLength = data->ReadVarInt();
 	std::vector<unsigned short> palette;
@@ -42,24 +36,17 @@ PackedSection World::ParseSection(StreamInput *data, Vector position) {
 	std::vector<unsigned char> skyLight;
 	if (dimension == 0)
 		skyLight = data->ReadByteArray(2048);
-	return PackedSection(position, dataArray.data(), dataArray.size(), blockLight.data(),
-	               (skyLight.size() > 0 ? skyLight.data() : nullptr), bitsPerBlock, palette);
-}
 
-World::~World() {
+    long long *blockData = reinterpret_cast<long long*>(dataArray.data());
+    for (int i = 0; i < dataArray.size() / sizeof(long long); i++)
+        endswap(blockData[i]);
+    std::vector<long long> blockArray (blockData, blockData + dataArray.size() / sizeof (long long));
+
+
+    return Section(position, bitsPerBlock, std::move(palette), std::move(blockArray), std::move(blockLight), std::move(skyLight));
 }
 
-Block & World::GetBlock(Vector worldPosition)
-{
-    Vector sectionPos(std::floor(worldPosition.x / 16.0), std::floor(worldPosition.y / 16.0), std::floor(worldPosition.z / 16.0));    
-    auto it = cachedSections.find(sectionPos);
-    if (it == cachedSections.end()) {
-        static Block fallbackBlock;
-        return fallbackBlock;
-    }
-    Section& section = it->second;
-    Block& block = section.GetBlock(worldPosition - sectionPos * 16);
-    return block;
+World::~World() {
 }
 
 World::World() {
@@ -67,7 +54,7 @@ World::World() {
 
 bool World::isPlayerCollides(double X, double Y, double Z) {
 	Vector PlayerChunk(floor(X / 16.0), floor(Y / 16.0), floor(Z / 16.0));
-    if (cachedSections.find(PlayerChunk) == cachedSections.end() || cachedSections.find(PlayerChunk - Vector(0,1,0)) == cachedSections.end())
+    if (sections.find(PlayerChunk) == sections.end() || sections.find(PlayerChunk - Vector(0,1,0)) == sections.end())
         return true;
 	std::vector<Vector> closestSectionsCoordinates = {
 			Vector(PlayerChunk.x, PlayerChunk.y, PlayerChunk.z),
@@ -80,7 +67,7 @@ bool World::isPlayerCollides(double X, double Y, double Z) {
 	};
 	std::vector<Vector> closestSections;
 	for (auto &coord:closestSectionsCoordinates) {
-        if (cachedSections.find(coord) != cachedSections.end())
+        if (sections.find(coord) != sections.end())
             closestSections.push_back(coord);
 	}
 
@@ -102,7 +89,7 @@ bool World::isPlayerCollides(double X, double Y, double Z) {
 		for (int x = 0; x < 16; x++) {
 			for (int y = 0; y < 16; y++) {
 				for (int z = 0; z < 16; z++) {
-					Block block = section.GetBlock(Vector(x, y, z));
+					BlockId block = section.GetBlockId(Vector(x, y, z));
 					if (block.id == 0 || block.id == 31)
 						continue;
 					AABB blockColl{(x + it.x * 16.0),
@@ -119,18 +106,18 @@ bool World::isPlayerCollides(double X, double Y, double Z) {
 
 std::vector<Vector> World::GetSectionsList() {
 	std::vector<Vector> sectionsList;
-    for (auto& it : cachedSections) {
+    for (auto& it : sections) {
         if (std::find(sectionsList.begin(), sectionsList.end(), it.first) == sectionsList.end())
             sectionsList.push_back(it.first);
     }
 	return sectionsList;
 }
 
-static Section fallbackSection = Section(PackedSection());
+static Section fallbackSection;
 
 const Section &World::GetSection(Vector sectionPos) {
-    auto result = cachedSections.find(sectionPos);
-    if (result == cachedSections.end()) {
+    auto result = sections.find(sectionPos);
+    if (result == sections.end()) {
         LOG(ERROR) << "Accessed not loaded section " << sectionPos;
         return fallbackSection;
     } else {
@@ -205,14 +192,14 @@ void World::DeleteEntity(unsigned int EntityId)
 }
 
 void World::ParseChunkData(std::shared_ptr<PacketBlockChange> packet) {
-    Block& block = this->GetBlock(packet->Position);
+    /*Block& block = this->GetBlock(packet->Position);
     block = Block(packet->BlockId >> 4, packet->BlockId & 15, block.light, block.sky);
     Vector sectionPos(std::floor(packet->Position.x / 16.0), std::floor(packet->Position.y / 16.0), std::floor(packet->Position.z / 16.0));
-    EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ sectionPos });
+    EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ sectionPos });*/
 }
 
 void World::ParseChunkData(std::shared_ptr<PacketMultiBlockChange> packet) {
-    std::vector<Vector> changedSections;
+    /*std::vector<Vector> changedSections;
     for (auto& it : packet->Records) {
         int x = (it.HorizontalPosition >> 4 & 15) + (packet->ChunkX * 16);
         int y = it.YCoordinate;
@@ -226,17 +213,17 @@ void World::ParseChunkData(std::shared_ptr<PacketMultiBlockChange> packet) {
             changedSections.push_back(sectionPos);
     }
     for (auto& sectionPos: changedSections)
-        EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ sectionPos });
+        EventAgregator::PushEvent(EventType::ChunkChanged, ChunkChangedData{ sectionPos });*/
 }
 
 void World::ParseChunkData(std::shared_ptr<PacketUnloadChunk> packet) {
     std::vector<std::map<Vector,Section>::iterator> toRemove;
-    for (auto it = cachedSections.begin(); it != cachedSections.end(); ++it) {
+    for (auto it = sections.begin(); it != sections.end(); ++it) {
         if (it->first.x == packet->ChunkX && it->first.z == packet->ChunkZ)
             toRemove.push_back(it);
     }
     for (auto& it : toRemove) {
         EventAgregator::PushEvent(EventType::ChunkDeleted, ChunkDeletedData{ it->first });
-        cachedSections.erase(it);        
+        sections.erase(it);        
     }
 }
\ No newline at end of file
diff --git a/src/World.hpp b/src/World.hpp
index 6ff0619..a5cf60c 100644
--- a/src/World.hpp
+++ b/src/World.hpp
@@ -16,17 +16,15 @@
 
 class World {
     int dimension = 0;
-	//std::map<Vector, PackedSection> sections;
-    std::map<Vector, Section> cachedSections;
 
-	PackedSection ParseSection(StreamInput *data, Vector position);
+    std::map<Vector, Section> sections;
+
+	Section ParseSection(StreamInput *data, Vector position);
 
     std::vector<Entity> entities;
 
     std::mutex entitiesMutex;
 
-    Block& GetBlock(Vector worldPosition);
-
 public:
 	World();
 
diff --git a/src/main.cpp b/src/main.cpp
index 0a6ad17..9c38814 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -16,12 +16,9 @@ const char *getTimeSinceProgramStart(void) {
 INITIALIZE_EASYLOGGINGPP
 
 
-#ifdef WIN32
-int CALLBACK WinMain(_In_ HINSTANCE hInstance, _In_ HINSTANCE hPrevInstance,
-    _In_ LPSTR lpCmdLine, _In_ int nCmdShow) {
-#else
-int main() {
-#endif
+#undef main
+
+int main(int argc, char** argv) {
 	el::Configurations loggerConfiguration;
 	el::Helpers::installCustomFormatSpecifier(
 			el::CustomFormatSpecifier("%startTime", std::bind(getTimeSinceProgramStart)));
@@ -37,6 +34,14 @@ int main() {
 
 	LOG(WARNING) << "Sizeof EventData is " << sizeof(EventData);
 
+    try {
+        if (SDL_Init(0) == -1)
+            throw std::runtime_error("SDL initialization failed: " + std::string(SDL_GetError()));
+    } catch (std::exception& e) {
+        LOG(ERROR) << e.what();
+        return -1;
+    }
+
 	ThreadGame game;
 	std::thread threadGame(&ThreadGame::Execute, game);