abomination.cpp

abomination.cpp

#ifndef ABOMINATION_CPP
#	define ABOMINATION_CPP

#	if __has_include(<algorithm>)
#		include <algorithm>
#	endif

#	if __has_include(<any>)
#		include <any>
#	endif

#	if __has_include(<array>)
#		include <array>
#	endif

#	if __has_include(<assert.h>)
#		include <assert.h>
#	endif

#	if __has_include(<atomic>)
#		include <atomic>
#	endif

#	if __has_include(<barrier>)
#		include <barrier>
#	endif

#	if __has_include(<bit>)
#		include <bit>
#	endif

#	if __has_include(<bitset>)
#		include <bitset>
#	endif

#	if __has_include(<cassert>)
#		include <cassert>
#	endif

#	if __has_include(<ccomplex>)
#		include <ccomplex>
#	endif

#	if __has_include(<cctype>)
#		include <cctype>
#	endif

#	if __has_include(<cerrno>)
#		include <cerrno>
#	endif

#	if __has_include(<cfenv>)
#		include <cfenv>
#	endif

#	if __has_include(<cfloat>)
#		include <cfloat>
#	endif

#	if __has_include(<charconv>)
#		include <charconv>
#	endif

#	if __has_include(<chrono>)
#		include <chrono>
#	endif

#	if __has_include(<cinttypes>)
#		include <cinttypes>
#	endif

#	if __has_include(<ciso646>)
#		include <ciso646>
#	endif

#	if __has_include(<climits>)
#		include <climits>
#	endif

#	if __has_include(<clocale>)
#		include <clocale>
#	endif

#	if __has_include(<cmath>)
#		include <cmath>
#	endif

#	if __has_include(<codecvt>)
#		include <codecvt>
#	endif

#	if __has_include(<compare>)
#		include <compare>
#	endif

#	if __has_include(<complex.h>)
#		include <complex.h>
#	endif

#	if __has_include(<complex>)
#		include <complex>
#	endif

#	if __has_include(<concepts>)
#		include <concepts>
#	endif

#	if __has_include(<condition_variable>)
#		include <condition_variable>
#	endif

#	if __has_include(<coroutine>)
#		include <coroutine>
#	endif

#	if __has_include(<csetjmp>)
#		include <csetjmp>
#	endif

#	if __has_include(<csignal>)
#		include <csignal>
#	endif

#	if __has_include(<cstdalign>)
#		include <cstdalign>
#	endif

#	if __has_include(<cstdarg>)
#		include <cstdarg>
#	endif

#	if __has_include(<cstdbool>)
#		include <cstdbool>
#	endif

#	if __has_include(<cstddef>)
#		include <cstddef>
#	endif

#	if __has_include(<cstdint>)
#		include <cstdint>
#	endif

#	if __has_include(<cstdio>)
#		include <cstdio>
#	endif

#	if __has_include(<cstdlib>)
#		include <cstdlib>
#	endif

#	if __has_include(<cstring>)
#		include <cstring>
#	endif

#	if __has_include(<ctgmath>)
#		include <ctgmath>
#	endif

#	if __has_include(<ctime>)
#		include <ctime>
#	endif

#	if __has_include(<ctype.h>)
#		include <ctype.h>
#	endif

#	if __has_include(<cuchar>)
#		include <cuchar>
#	endif

#	if __has_include(<cwchar>)
#		include <cwchar>
#	endif

#	if __has_include(<cwctype>)
#		include <cwctype>
#	endif

#	if __has_include(<debugging>)
#		include <debugging>
#	endif

#	if __has_include(<deque>)
#		include <deque>
#	endif

#	if __has_include(<errno.h>)
#		include <errno.h>
#	endif

#	if __has_include(<exception>)
#		include <exception>
#	endif

#	if __has_include(<execution>)
#		include <execution>
#	endif

#	if __has_include(<expected>)
#		include <expected>
#	endif

#	if __has_include(<experimental/algorithm>)
#		include <experimental/algorithm>
#	endif

#	if __has_include(<experimental/algorithm>)
#		include <experimental/algorithm>
#	endif

#	if __has_include(<experimental/algorithm>)
#		include <experimental/algorithm>
#	endif

#	if __has_include(<experimental/algorithm>)
#		include <experimental/algorithm>
#	endif

#	if __has_include(<experimental/array>)
#		include <experimental/array>
#	endif

#	if __has_include(<experimental/atomic>)
#		include <experimental/atomic>
#	endif

#	if __has_include(<experimental/barrier>)
#		include <experimental/barrier>
#	endif

#	if __has_include(<experimental/buffer>)
#		include <experimental/buffer>
#	endif

#	if __has_include(<experimental/chrono>)
#		include <experimental/chrono>
#	endif

#	if __has_include(<experimental/deque>)
#		include <experimental/deque>
#	endif

#	if __has_include(<experimental/deque>)
#		include <experimental/deque>
#	endif

#	if __has_include(<experimental/exception_list>)
#		include <experimental/exception_list>
#	endif

#	if __has_include(<experimental/execution_policy>)
#		include <experimental/execution_policy>
#	endif

#	if __has_include(<experimental/execution_policy>)
#		include <experimental/execution_policy>
#	endif

#	if __has_include(<experimental/executor>)
#		include <experimental/executor>
#	endif

#	if __has_include(<experimental/forward_list>)
#		include <experimental/forward_list>
#	endif

#	if __has_include(<experimental/forward_list>)
#		include <experimental/forward_list>
#	endif

#	if __has_include(<experimental/future>)
#		include <experimental/future>
#	endif

#	if __has_include(<experimental/future>)
#		include <experimental/future>
#	endif

#	if __has_include(<experimental/internet>)
#		include <experimental/internet>
#	endif

#	if __has_include(<experimental/io_context>)
#		include <experimental/io_context>
#	endif

#	if __has_include(<experimental/iterator>)
#		include <experimental/iterator>
#	endif

#	if __has_include(<experimental/latch>)
#		include <experimental/latch>
#	endif

#	if __has_include(<experimental/list>)
#		include <experimental/list>
#	endif

#	if __has_include(<experimental/list>)
#		include <experimental/list>
#	endif

#	if __has_include(<experimental/map>)
#		include <experimental/map>
#	endif

#	if __has_include(<experimental/map>)
#		include <experimental/map>
#	endif

#	if __has_include(<experimental/memory>)
#		include <experimental/memory>
#	endif

#	if __has_include(<experimental/memory>)
#		include <experimental/memory>
#	endif

#	if __has_include(<experimental/netfwd>)
#		include <experimental/netfwd>
#	endif

#	if __has_include(<experimental/numeric>)
#		include <experimental/numeric>
#	endif

#	if __has_include(<experimental/numeric>)
#		include <experimental/numeric>
#	endif

#	if __has_include(<experimental/propagate_const>)
#		include <experimental/propagate_const>
#	endif

#	if __has_include(<experimental/random>)
#		include <experimental/random>
#	endif

#	if __has_include(<experimental/ratio>)
#		include <experimental/ratio>
#	endif

#	if __has_include(<experimental/regex>)
#		include <experimental/regex>
#	endif

#	if __has_include(<experimental/scope>)
#		include <experimental/scope>
#	endif

#	if __has_include(<experimental/set>)
#		include <experimental/set>
#	endif

#	if __has_include(<experimental/set>)
#		include <experimental/set>
#	endif

#	if __has_include(<experimental/socket>)
#		include <experimental/socket>
#	endif

#	if __has_include(<experimental/source_location>)
#		include <experimental/source_location>
#	endif

#	if __has_include(<experimental/string>)
#		include <experimental/string>
#	endif

#	if __has_include(<experimental/string>)
#		include <experimental/string>
#	endif

#	if __has_include(<experimental/system_error>)
#		include <experimental/system_error>
#	endif

#	if __has_include(<experimental/task_block>)
#		include <experimental/task_block>
#	endif

#	if __has_include(<experimental/timer>)
#		include <experimental/timer>
#	endif

#	if __has_include(<experimental/tuple>)
#		include <experimental/tuple>
#	endif

#	if __has_include(<experimental/type_traits>)
#		include <experimental/type_traits>
#	endif

#	if __has_include(<experimental/type_traits>)
#		include <experimental/type_traits>
#	endif

#	if __has_include(<experimental/unordered_map>)
#		include <experimental/unordered_map>
#	endif

#	if __has_include(<experimental/unordered_map>)
#		include <experimental/unordered_map>
#	endif

#	if __has_include(<experimental/unordered_set>)
#		include <experimental/unordered_set>
#	endif

#	if __has_include(<experimental/unordered_set>)
#		include <experimental/unordered_set>
#	endif

#	if __has_include(<experimental/utility>)
#		include <experimental/utility>
#	endif

#	if __has_include(<experimental/vector>)
#		include <experimental/vector>
#	endif

#	if __has_include(<experimental/vector>)
#		include <experimental/vector>
#	endif

#	if __has_include(<fenv.h>)
#		include <fenv.h>
#	endif

#	if __has_include(<filesystem>)
#		include <filesystem>
#	endif

#	if __has_include(<flat_map>)
#		include <flat_map>
#	endif

#	if __has_include(<flat_set>)
#		include <flat_set>
#	endif

#	if __has_include(<float.h>)
#		include <float.h>
#	endif

#	if __has_include(<format>)
#		include <format>
#	endif

#	if __has_include(<forward_list>)
#		include <forward_list>
#	endif

#	if __has_include(<fstream>)
#		include <fstream>
#	endif

#	if __has_include(<functional>)
#		include <functional>
#	endif

#	if __has_include(<future>)
#		include <future>
#	endif

#	if __has_include(<generator>)
#		include <generator>
#	endif

#	if __has_include(<hazard_pointer>)
#		include <hazard_pointer>
#	endif

#	if __has_include(<initializer_list>)
#		include <initializer_list>
#	endif

#	if __has_include(<inttypes.h>)
#		include <inttypes.h>
#	endif

#	if __has_include(<iomanip>)
#		include <iomanip>
#	endif

#	if __has_include(<ios>)
#		include <ios>
#	endif

#	if __has_include(<iosfwd>)
#		include <iosfwd>
#	endif

#	if __has_include(<iostream>)
#		include <iostream>
#	endif

#	if __has_include(<iso646.h>)
#		include <iso646.h>
#	endif

#	if __has_include(<istream>)
#		include <istream>
#	endif

#	if __has_include(<iterator>)
#		include <iterator>
#	endif

#	if __has_include(<latch>)
#		include <latch>
#	endif

#	if __has_include(<limits.h>)
#		include <limits.h>
#	endif

#	if __has_include(<limits>)
#		include <limits>
#	endif

#	if __has_include(<linalg>)
#		include <linalg>
#	endif

#	if __has_include(<list>)
#		include <list>
#	endif

#	if __has_include(<locale.h>)
#		include <locale.h>
#	endif

#	if __has_include(<locale>)
#		include <locale>
#	endif

#	if __has_include(<map>)
#		include <map>
#	endif

#	if __has_include(<math.h>)
#		include <math.h>
#	endif

#	if __has_include(<mdspan>)
#		include <mdspan>
#	endif

#	if __has_include(<memory>)
#		include <memory>
#	endif

#	if __has_include(<memory_resource>)
#		include <memory_resource>
#	endif

#	if __has_include(<mutex>)
#		include <mutex>
#	endif

#	if __has_include(<new>)
#		include <new>
#	endif

#	if __has_include(<numbers>)
#		include <numbers>
#	endif

#	if __has_include(<numeric>)
#		include <numeric>
#	endif

#	if __has_include(<optional>)
#		include <optional>
#	endif

#	if __has_include(<ostream>)
#		include <ostream>
#	endif

#	if __has_include(<print>)
#		include <print>
#	endif

#	if __has_include(<queue>)
#		include <queue>
#	endif

#	if __has_include(<random>)
#		include <random>
#	endif

#	if __has_include(<ranges>)
#		include <ranges>
#	endif

#	if __has_include(<ratio>)
#		include <ratio>
#	endif

#	if __has_include(<rcu>)
#		include <rcu>
#	endif

#	if __has_include(<regex>)
#		include <regex>
#	endif

#	if __has_include(<scoped_allocator>)
#		include <scoped_allocator>
#	endif

#	if __has_include(<semaphore>)
#		include <semaphore>
#	endif

#	if __has_include(<set>)
#		include <set>
#	endif

#	if __has_include(<setjmp.h>)
#		include <setjmp.h>
#	endif

#	if __has_include(<shared_mutex>)
#		include <shared_mutex>
#	endif

#	if __has_include(<signal.h>)
#		include <signal.h>
#	endif

#	if __has_include(<source_location>)
#		include <source_location>
#	endif

#	if __has_include(<span>)
#		include <span>
#	endif

#	if __has_include(<spanstream>)
#		include <spanstream>
#	endif

#	if __has_include(<sstream>)
#		include <sstream>
#	endif

#	if __has_include(<stack>)
#		include <stack>
#	endif

#	if __has_include(<stacktrace>)
#		include <stacktrace>
#	endif

#	if __has_include(<stdalign.h>)
#		include <stdalign.h>
#	endif

#	if __has_include(<stdarg.h>)
#		include <stdarg.h>
#	endif

#	if __has_include(<stdatomic.h>)
#		include <stdatomic.h>
#	endif

#	if __has_include(<stdbool.h>)
#		include <stdbool.h>
#	endif

#	if __has_include(<stddef.h>)
#		include <stddef.h>
#	endif

#	if __has_include(<stdexcept>)
#		include <stdexcept>
#	endif

#	if __has_include(<stdfloat>)
#		include <stdfloat>
#	endif

#	if __has_include(<stdint.h>)
#		include <stdint.h>
#	endif

#	if __has_include(<stdio.h>)
#		include <stdio.h>
#	endif

#	if __has_include(<stdlib.h>)
#		include <stdlib.h>
#	endif

#	if __has_include(<stop_token>)
#		include <stop_token>
#	endif

#	if __has_include(<streambuf>)
#		include <streambuf>
#	endif

#	if __has_include(<string.h>)
#		include <string.h>
#	endif

#	if __has_include(<string>)
#		include <string>
#	endif

#	if __has_include(<string_view>)
#		include <string_view>
#	endif

#	if __has_include(<strstream>)
#		include <strstream>
#	endif

#	if __has_include(<syncstream>)
#		include <syncstream>
#	endif

#	if __has_include(<system_error>)
#		include <system_error>
#	endif

#	if __has_include(<text_encoding>)
#		include <text_encoding>
#	endif

#	if __has_include(<tgmath.h>)
#		include <tgmath.h>
#	endif

#	if __has_include(<thread>)
#		include <thread>
#	endif

#	if __has_include(<time.h>)
#		include <time.h>
#	endif

#	if __has_include(<tuple>)
#		include <tuple>
#	endif

#	if __has_include(<type_traits>)
#		include <type_traits>
#	endif

#	if __has_include(<typeindex>)
#		include <typeindex>
#	endif

#	if __has_include(<typeinfo>)
#		include <typeinfo>
#	endif

#	if __has_include(<uchar.h>)
#		include <uchar.h>
#	endif

#	if __has_include(<unordered_map>)
#		include <unordered_map>
#	endif

#	if __has_include(<unordered_set>)
#		include <unordered_set>
#	endif

#	if __has_include(<utility>)
#		include <utility>
#	endif

#	if __has_include(<valarray>)
#		include <valarray>
#	endif

#	if __has_include(<variant>)
#		include <variant>
#	endif

#	if __has_include(<vector>)
#		include <vector>
#	endif

#	if __has_include(<version>)
#		include <version>
#	endif

#	if __has_include(<wchar.h>)
#		include <wchar.h>
#	endif

#	if __has_include(<wctype.h>)
#		include <wctype.h>
#	endif

namespace std {}
namespace std::chrono {}
namespace std::chrono_literals {}
namespace std::complex_literals {}
namespace std::execution {}
namespace std::experimental {}
namespace std::experimental::net {}
namespace std::experimental::net::ip {}
namespace std::experimental::net::ip::multicast {}
namespace std::experimental::net::ip::unicast {}
namespace std::experimental::pmr {}
namespace std::experimental::ranges {}
namespace std::experimental::ranges::tag {}
namespace std::experimental::reflect {}
namespace std::experimental::reflect::v1 {}
namespace std::filesystem {}
namespace std::literals {}
namespace std::literals::chrono_literals {}
namespace std::literals::complex_literals {}
namespace std::literals::string_literals {}
namespace std::literals::string_view_literals {}
namespace std::numbers {}
namespace std::placeholders {}
namespace std::pmr {}
namespace std::ranges {}
namespace std::ranges::views {}
namespace std::regex_constants {}
namespace std::rel_ops {}
namespace std::string_literals {}
namespace std::string_view_literals {}
namespace std::this_thread {}

using namespace std;
using namespace std::chrono;
using namespace std::chrono_literals;
using namespace std::complex_literals;
using namespace std::execution;
using namespace std::experimental;
using namespace std::experimental::net;
using namespace std::experimental::net::ip;
using namespace std::experimental::net::ip::multicast;
using namespace std::experimental::net::ip::unicast;
using namespace std::experimental::pmr;
using namespace std::experimental::ranges;
using namespace std::experimental::ranges::tag;
using namespace std::experimental::reflect;
using namespace std::experimental::reflect::v1;
using namespace std::filesystem;
using namespace std::literals;
using namespace std::literals::chrono_literals;
using namespace std::literals::complex_literals;
using namespace std::literals::string_literals;
using namespace std::literals::string_view_literals;
using namespace std::numbers;
using namespace std::placeholders;
using namespace std::pmr;
using namespace std::ranges;
using namespace std::ranges::views;
using namespace std::regex_constants;
using namespace std::rel_ops;
using namespace std::string_literals;
using namespace std::string_view_literals;
using namespace std::this_thread;

#endif