#include <bits/stdc++.h>

#include <cstdlib>

using namespace std;

#define concat2(a, b) a##b

#define concat(a, b) concat2(a, b)

#define u(a) concat(a, __LINE__)

#define check2(x, y) \

do { \

cout << x; \

if (string(x) != #y) \

cout << " " << #y; \

else \

cout << " ------"; \

cout << endl; \

} while (0)

#define check(x) \

static class c##x { \

public: \

c##x() \

{ \

if (std::getenv("features")) \

check2(#x, x); \

} \

} c##x // global instantiation

check(__GNUC__);

check(__GNUC_MINOR__);

check(__GNUC_PATCHLEVEL__);

check(__GNUG__);

check(__clang__);

check(__clang_major__);

check(__clang_minor__);

check(__clang_patchlevel__);

check(__cplusplus);

check(__cpp_exceptions);

check(__cpp_rtti);

check(__cpp_static_assert);

check(__cpp_delegating_constructors);

check(__cpp_rvalue_references);

check(__cpp_alias_templates);

check(__cpp_variadic_templates);

check(__cpp_unicode_characters);

check(__cpp_constexpr);

check(__cpp_decltype);

check(__cpp_raw_strings);

check(__cpp_ref_qualifiers);

check(__cpp_unicode_literals);

check(__cpp_initializer_lists);

check(__cpp_threadsafe_static_init);

check(__cpp_attributes);

check(__cpp_nsdmi);

check(__cpp_user_defined_literals);

check(__cpp_lambdas);

check(__cpp_range_based_for);

check(__cpp_lib_result_of_sfinae);

check(__cpp_binary_literals);

check(__cpp_lib_is_null_pointer);

check(__cpp_lib_allocator_is_always_equal);

check(__cpp_lib_allocator_traits_is_always_equal);

check(__cpp_lib_incomplete_container_elements);

check(__cpp_inheriting_constructors);

check(__cpp_hex_float);

check(__cpp_aggregate_nsdmi);

check(__cpp_decltype_auto);

check(__cpp_generic_lambdas);

check(__cpp_init_captures);

check(__cpp_lib_exchange_function);

check(__cpp_lib_integer_sequence);

check(__cpp_lib_integral_constant_callable);

check(__cpp_lib_robust_nonmodifying_seq_ops);

check(__cpp_lib_string_udls);

check(__cpp_lib_transformation_trait_aliases);

check(__cpp_lib_tuples_by_type);

check(__cpp_return_type_deduction);

check(__cpp_variable_templates);

check(__cpp_sized_deallocation);

check(__cpp_lib_is_final);

check(__cpp_lib_make_reverse_iterator);

check(__cpp_lib_tuple_element_t);

check(__cpp_lib_transparent_operators);

check(__cpp_enumerator_attributes);

check(__cpp_lib_invoke);

check(__cpp_lib_nonmember_container_access);

check(__cpp_lib_uncaught_exceptions);

check(__cpp_lib_unordered_map_insertion);

check(__cpp_lib_unordered_map_try_emplace);

check(__cpp_lib_void_t);

check(__cpp_namespace_attributes);

check(__cpp_nontype_template_args);

check(__cpp_lib_bool_constant);

check(__cpp_lib_as_const);

check(__cpp_lib_logical_traits);

check(__cpp_lib_type_trait_variable_templates);

check(__cpp_noexcept_function_type);

check(__cpp_aggregate_bases);

check(__cpp_capture_star_this);

check(__cpp_fold_expressions);

check(__cpp_lib_addressof_constexpr);

check(__cpp_lib_apply);

check(__cpp_lib_array_constexpr);

check(__cpp_lib_boyer_moore_searcher);

check(__cpp_lib_clamp);

check(__cpp_lib_is_swappable);

check(__cpp_lib_not_fn);

check(__cpp_lib_sample);

check(__cpp_lib_string_view);

check(__cpp_aligned_new);

check(__cpp_guaranteed_copy_elision);

check(__cpp_if_constexpr);

check(__cpp_inline_variables);

check(__cpp_lib_has_unique_object_representations);

check(__cpp_lib_launder);

check(__cpp_lib_make_from_tuple);

check(__cpp_lib_node_extract);

check(__cpp_lib_optional);

check(__cpp_lib_raw_memory_algorithms);

check(__cpp_nontype_template_parameter_auto);

check(__cpp_structured_bindings);

check(__cpp_lib_constexpr_char_traits);

check(__cpp_template_template_args);

check(__cpp_variadic_using);

check(__cpp_deduction_guides);

check(__cpp_lib_is_aggregate);

check(__cpp_lib_is_invocable);

check(__cpp_transactional_memory);

check(__cpp_concepts);

check(__cpp_conditional_explicit);

check(__cpp_impl_destroying_delete);

check(__cpp_lib_destroying_delete);

check(__cpp_nontype_template_parameter_class);

check(__cpp_char8_t);

check(__cpp_lib_char8_t);

check(__cpp_lib_is_constant_evaluated);

check(__cpp_lib_erase_if);

check(__cpp_lib_bounded_array_traits);

check(__cpp_lib_bind_front);

check(__cpp_aggregate_paren_init);

check(__cpp_consteval);

check(__cpp_constexpr_in_decltype);

check(__cpp_constinit);

check(__cpp_coroutines);

check(__cpp_impl_three_way_comparison);

check(__cpp_lib_any);

check(__cpp_lib_assume_aligned);

check(__cpp_lib_atomic_flag_test);

check(__cpp_lib_atomic_float);

check(__cpp_lib_atomic_is_always_lock_free);

check(__cpp_lib_atomic_lock_free_type_aliases);

check(__cpp_lib_atomic_ref);

check(__cpp_lib_atomic_shared_ptr);

check(__cpp_lib_atomic_value_initialization);

check(__cpp_lib_atomic_wait);

check(__cpp_lib_barrier);

check(__cpp_lib_bit_cast);

check(__cpp_lib_bitops);

check(__cpp_lib_byte);

check(__cpp_lib_chrono);

check(__cpp_lib_chrono_udls);

check(__cpp_lib_complex_udls);

check(__cpp_lib_concepts);

check(__cpp_lib_constexpr);

check(__cpp_lib_constexpr_algorithms);

check(__cpp_lib_constexpr_complex);

check(__cpp_lib_constexpr_dynamic_alloc);

check(__cpp_lib_constexpr_functional);

check(__cpp_lib_constexpr_iterator);

check(__cpp_lib_constexpr_memory);

check(__cpp_lib_constexpr_numeric);

check(__cpp_lib_constexpr_string);

check(__cpp_lib_constexpr_string_view);

check(__cpp_lib_constexpr_swap_algorithms);

check(__cpp_lib_constexpr_tuple);

check(__cpp_lib_constexpr_utility);

check(__cpp_lib_constexpr_vector);

check(__cpp_lib_enable_shared_from_this);

check(__cpp_lib_endian);

check(__cpp_lib_execution);

check(__cpp_lib_experimental_any);

check(__cpp_lib_experimental_boyer_moore_searching);

check(__cpp_lib_experimental_detect);

check(__cpp_lib_experimental_erase_if);

check(__cpp_lib_experimental_filesystem);

check(__cpp_lib_experimental_gcd_lcm);

check(__cpp_lib_experimental_logical_traits);

check(__cpp_lib_experimental_make_array);

check(__cpp_lib_experimental_memory_resources);

check(__cpp_lib_experimental_net);

check(__cpp_lib_experimental_net_extensible);

check(__cpp_lib_experimental_not_fn);

check(__cpp_lib_experimental_observer_ptr);

check(__cpp_lib_experimental_optional);

check(__cpp_lib_experimental_ostream_joiner);

check(__cpp_lib_experimental_randint);

check(__cpp_lib_experimental_sample);

check(__cpp_lib_experimental_source_location);

check(__cpp_lib_experimental_string_view);

check(__cpp_lib_experimental_tuple);

check(__cpp_lib_experimental_type_trait_variable_templates);

check(__cpp_lib_filesystem);

check(__cpp_lib_format);

check(__cpp_lib_gcd);

check(__cpp_lib_gcd_lcm);

check(__cpp_lib_generic_associative_lookup);

check(__cpp_lib_generic_unordered_lookup);

check(__cpp_lib_hardware_interference_size);

check(__cpp_lib_hypot);

check(__cpp_lib_int_pow2);

check(__cpp_lib_interpolate);

check(__cpp_lib_is_layout_compatible);

check(__cpp_lib_is_pointer_interconvertible);

check(__cpp_lib_jthread);

check(__cpp_lib_latch);

check(__cpp_lib_lcm);

check(__cpp_lib_list_remove_return_type);

check(__cpp_lib_make_unique);

check(__cpp_lib_map_insertion);

check(__cpp_lib_map_try_emplace);

check(__cpp_lib_math_constants);

check(__cpp_lib_math_special_functions);

check(__cpp_lib_memory_resource);

check(__cpp_lib_nothrow_convertible);

check(__cpp_lib_null_iterators);

check(__cpp_lib_parallel_algorithm);

check(__cpp_lib_polymorphic_allocator);

check(__cpp_lib_quoted_string_io);

check(__cpp_lib_ranges);

check(__cpp_lib_remove_cvref);

check(__cpp_lib_scoped_lock);

check(__cpp_lib_semaphore);

check(__cpp_lib_shared_mutex);

check(__cpp_lib_shared_ptr_arrays);

check(__cpp_lib_shared_ptr_weak_type);

check(__cpp_lib_shared_timed_mutex);

check(__cpp_lib_shift);

check(__cpp_lib_smart_ptr_default_init);

check(__cpp_lib_source_location);

check(__cpp_lib_span);

check(__cpp_lib_ssize);

check(__cpp_lib_starts_ends_with);

check(__cpp_lib_syncbuf);

check(__cpp_lib_three_way_comparison);

check(__cpp_lib_to_address);

check(__cpp_lib_to_array);

check(__cpp_lib_to_chars);

check(__cpp_lib_type_identity);

check(__cpp_lib_unwrap_ref);

check(__cpp_lib_variant);

check(__cpp_constexpr_dynamic_alloc);

check(__cpp_designated_initializers);

check(__cpp_lib_generic_unordered_hash_lookup);

check(__cpp_modules);

check(__cpp_using_enum);

check(__cpp_impl_coroutine);

check(__cpp_lib_coroutine);

check(__cpp_lib_integer_comparison_functions);

check(__cpp_lib_is_nothrow_convertible);

check(__cpp_cxx23_stub);

check(__cpp_lib_cxx23_stub);

check(__cpp_lib_smart_ptr_for_overwrite);

check(__cpp_lib_is_scoped_enum);

check(__cpp_lib_stacktrace);

check(__cpp_lib_stdatomic_h);

check(__cpp_lib_string_contains);

check(__cpp_size_t_suffix);