text: // Copyright comment
  
  #pragma once
  
  #include <iostream>
  #include <vector>
  #include <cstdint>
  #include <string>
  
  // Indented preprocessor statements
  #if defined(PLATFORM_WINDOWS_PHONE)
      #if defined(PLATFORM_MSVC_ARM)
          // NEON introduced in VS2012
          #if (_MSC_VER >= 1700)
              #define PLATFORM_NEON 1
          #endif
      #endif
  #elif defined(PLATFORM_MSVC_X86)
      // SSSE3, SSE4.1, SSE4.2, PCLMUL introduced in VS2008
      #if (_MSC_VER >= 1500)
          #define PLATFORM_SSSE3 1
          #define PLATFORM_SSE41 1
          #define PLATFORM_SSE42 1
          #define PLATFORM_PCLMUL 1
      #endif
      // AVX and AVX2 introduced in VS2012
      #if (_MSC_VER >= 1700)
          #define PLATFORM_AVX 1
          #define PLATFORM_AVX2 1
      #endif
  #endif
  
  // Namespaces
  namespace test
  {
  
  // Using expressions
  
  /// @ingroup finite_field_layers
  ///
  /// @brief Template alias for the common set of finite field
  ///        layers used in most stacks
  template<class Field, class SuperCoder>
  using finite_field_layers =
      finite_field_math<typename fifi::default_field<Field>::type,
      // Test comment
      finite_field<Field, SuperCoder>>;
  
  /// @ingroup coefficient_generator_layers
  ///
  /// @brief Generates an uniform random coefficient (from the
  ///        chosen Finite Field) for every symbol. In addition
  ///        using the pivot_aware_generate means that we will only
  ///        generate non-zero coefficients for symbols which are
  ///        available locally.
  template<class Features, class SuperCoder>
  using on_the_fly_generator =
      kodo_core::check_partial_generator<
      // Test comment
      kodo_core::uniform_generator_layers::type<Features,
      kodo_core::pivot_aware_generator<
      SuperCoder> > >;
  
  // Expression with template disambiguator
  using type = typename std::conditional<
               Predicate<T>::value,
               typename conditional_append<Predicate,
               typename TypeList::template append<T>, List...>::type,
               typename conditional_append<Predicate,
               TypeList, List...>::type>::type;
  
  // Template stacks
  
  template
  <
      class MainStack,
      class Features
  >
  class full_vector_recoding_stack : public
      // Payload API
      kodo_core::payload_info<
      // Codec Header API
      kodo_core::default_off_systematic_encoder<
      kodo_core::symbol_id_encoder<
      // Symbol ID API
      recoder_symbol_id<
      // Coefficient Generator API
      kodo_core::uniform_generator_layers::type<Features,
      kodo_core::pivot_aware_generator<
      // Encoder API
      kodo_core::write_symbol_tracker<
      kodo_core::zero_symbol_encoder<
      kodo_core::trace_write_symbol<kodo_core::find_enable_trace<Features>,
      kodo_core::trace_symbol<kodo_core::find_enable_trace<Features>,
      kodo_core::linear_block_encoder<
      // Coefficient Storage API
      kodo_core::coefficient_value_access<
      // Proxy
      kodo_core::proxy_layer<MainStack,
      kodo_core::final_layer
      > > > > > > > > > > > > >
  { };
  
  template<class T>
  struct is_regular :
      // Comment 2
      std::integral_constant<bool,
      // Comment 3
      std::is_default_constructible<T>::value &&
      // Comment 4
      std::is_move_assignable<T>::value>
  { };
  
  class client : public
      links::message_handler<links::message,
      message_printer<
      links::link
      >>
  {
  protected:
  
      /// Helper struct to determine if two classes have the same field types
      template<class T>
      struct is_same_field
      {
          static const bool value =
              std::is_same<typename T::field_type, field_type>::value;
      };
  };
  
  }
  
  // Nested namespaces
  namespace test
  {
  
  namespace api
  {
  inline std::shared_ptr<final_interface> build(final_interface* stack)
  {
      auto api = dynamic_cast<build_interface*>(stack);
      assert(api);
      return api->build();
  }
  }
  
  namespace
  {
  struct dummy_one
  {
      template<class Factory>
      void construct(Factory& the_factory)
      {
          (void) the_factory;
          m_construct();
      }
  
      stub::function<void()> m_construct;
  };
  }
  
  }
  
  // Free functions
  
  /// @copydoc layer::multipy_add(uint8_t*, const uint8_t*,
  ///                             value_type, uint32_t)
  void multiply_add(uint8_t* symbol_dest,
                    const uint8_t* symbol_src,
                    value_type coefficient, uint32_t symbol_size)
  {
      assert(m_field);
      assert(symbol_dest != 0);
      assert(symbol_src != 0);
      assert(symbol_size > 0);
  
      coefficient = fifi::pack_constant<field_type>(coefficient);
  
      m_field->region_multiply_add(symbol_dest, symbol_src, coefficient,
                                   symbol_size);
  }
  
  template<typename U>
  static auto test(int) ->
      decltype(std::declval<U>().some_function(), yes());
  
  template<class SuperCoder>
  inline auto
  vandermonde_matrix_base::config::construct_matrix(uint32_t symbols) ->
      std::shared_ptr<generator_matrix>
  {
      // Something
  }
  
  template<
      class Field,
      class TraceTag
  >
  auto coder(const std::string& name) ->
      boost::python::class_<Coder<Field, TraceTag>, boost::noncopyable>
  {
      // Something
  }
  
  template<std::size_t... Is, class F, class... Args>
  inline auto easy_bind(indices<Is...>, F const& f, Args&&... args) ->
      decltype(std::bind(
          f, std::forward<Args>(args)..., placeholder<Is + 1> {} ...))
  {
      return std::bind(
          f, std::forward<Args>(args)..., placeholder<Is + 1> {} ...);
  }
  
  template<class R, class... FArgs, class... Args>
  inline auto easy_bind(std::function<R(FArgs...)> f, Args&&... args) ->
      decltype(detail::easy_bind(
          detail::build_indices<sizeof...(FArgs) - sizeof...(Args)> {},
          f, std::forward<Args>(args)...))
  {
      return detail::easy_bind(
          detail::build_indices<sizeof...(FArgs) - sizeof...(Args)> {},
          f, std::forward<Args>(args)...);
  }
  
  template <typename R, typename T, typename... FArgs, typename... Args>
  inline auto easy_bind(R(T::*mf)(FArgs...), Args&&... args) ->
      decltype(detail::easy_bind(
          detail::build_indices<(sizeof...(FArgs) + 1) - sizeof...(Args)>(),
          mf, std::forward<Args>(args)...))
  {
      // The extra argument is the object pointer (this)
      static_assert(sizeof...(Args) <= sizeof...(FArgs) + 1,
                    "Too many arguments to easy_bind");
  
      return detail::easy_bind(
          detail::build_indices<(sizeof...(FArgs) + 1) - sizeof...(Args)>(),
          mf, std::forward<Args>(args)...);
  }
  
  template
  <
      class T,
      typename std::enable_if<has_region_multiply_constant<T>::value,
                              uint8_t>::type = 0
  >
  inline void region_multiply_constant(T& t, uint8_t* dest,
                                       typename T::value_type constant,
                                       uint32_t size)
  {
      t.region_multiply_constant(dest, constant, size);
  }
  
  template
  <
      typename... Types,
      // Comment 1
      typename I = std::make_index_sequence<
          // Comment 2
          std::tuple_size<std::tuple<Types...>>::value>
  >
  constexpr auto tuple_to_array(std::tuple<Types...>&& tuple);
  
  
  #ifdef __cplusplus
  extern "C"
  {
  #endif
  
  KODOC_API
  uint8_t kodoc_has_write_payload(kodoc_coder_t coder);
  
  KODOC_API
  void kodoc_set_mutable_symbols(
      kodoc_coder_t decoder, uint8_t* data, uint32_t size);
  
  #ifdef __cplusplus
  }
  #endif
  
  namespace fifi
  {
  #ifdef PLATFORM_AVX2
  
  namespace detail
  {
  inline void multiply_helper(__m256i& low, __m256i& high,
                              __m256i*& table_ptr, __m256i& sum)
  {
      __m256i table1, table2;
      __m256i h, l, product;
  
      // Load the 32-byte row that contains the pre-calculated
      // multiplication results with the low-half of the constant
      table1 = _mm256_loadu_si256(table_ptr++);
  }
  }
  
  #else
  
  avx2_binary8_full_table::avx2_binary8_full_table()
  {
      (void) m_table_one;
      (void) m_table_two;
  }
  
  void avx2_binary8_full_table::region_add(
      uint8_t*, const uint8_t*, uint32_t) const
  {
      // Not implemented
      assert(0 && "This line should never be executed");
  }
  
  #endif
  }
  
  // Enum
  enum error_type
  {
      failed_open_file = 1,
      failed_open_file = 2
  };
  
  // Normal class
  class my_class
  {
  public:
  
      // Constructors
  
      my_class() :
          m_first(0U),
          m_second(1U)
      { }
  
      my_class() :
          m_vector { 1, 2, 3, 4 },
          m_second(1U)
      { }
  
      // Make sure that this base class cannot be instantiated
      factory(kodoc_factory_t factory,
              std::function<void(kodoc_factory_t)> deleter) :
          m_factory(factory, deleter)
      { }
  
      decoder_factory(codec codec, field field,
                      uint32_t max_symbols, uint32_t max_symbol_size) :
          factory(kodoc_new_decoder_factory(
              (int32_t)codec, (int32_t)field, max_symbols, max_symbol_size),
              [](kodoc_factory_t factory) { kodoc_delete_factory(factory); })
      { }
  
      io_service() :
          m_io_service(
              score_new_io_service(), [](score_io_service_t io)
          {
              score_delete_io_service(io);
          })
      { }
  
      io_service() :
          m_io_service(
              score_new_io_service(),
              {
                  1, 2, 3
              })
      { }
  
      template
      <
          class T = Value,
          typename std::enable_if<
              std::is_default_constructible<T>::value, uint8_t>::type = 0
      >
      resource_pool() :
          m_pool(std::make_shared<impl>(
              allocate_function(std::make_shared<value_type>)))
      { }
  
  public:
  
      // Function calls
      void function_calls()
      {
          srand(static_cast<uint32_t>(time(0)));
  
          assert(m_socket && "Invalid socket in queue_async_receive");
  
          assert(cancelled == 0 &&
                 "Rate limiter send called multiple times without "
                 "waiting for callback!");
  
          m_timer->async_wait(std::bind(&rate_limiter::timeout_handler,
                                        this, std::placeholders::_1, callback));
  
          namespace ph = std::placeholders;
  
          m_socket->async_receive_from(
              boost::asio::buffer(m_receive_buffer), *ep, std::bind(
                  &sockets::handle_async_receive_from, this,
                  ph::_1, ph::_2, ep));
  
          m_redundancy_estimator.sample(
              (1.0 + m_redundancy_estimator.estimate()) *
              m_generation_size() / m_worst.get() - 1.0);
  
          m_formatters.insert(std::make_pair(
              "csv", std::shared_ptr<tables::format>(new tables::csv_format())),
              third_param);
  
          EXPECT_TRUE(main_stack->copy_from_symbols.expect_calls().with(
              storage::storage(data))
              .to_bool());
  
          // Before function
          m_socket->async_receive_from(
              // Line 1
              looooooooooooooooong_function_name1(m_receive_buffer),
              // Line 2
              { 1, 2, 3, 4 },
              // Line 3
              looooooooooooooooong_function_name2(
                  // Line 4
                  &sockets::handle_async_receive_from, this,
                  ph::_1, ph::_2, ep));
  
  
          // Initializer block within a function call
          m_output_queue.insert(m_output_queue.begin(),
                                vector { 1, 2, 3 });
  
          m_output_queue.insert(m_output_queue.begin(),
                                {
                                    1, 2, 3
                                },
                                more);
  
          m_output_queue.insert(
              {
                  1, 2, 3
              },
              m_output_queue.end());
  
          std::map<uint32_t, uint32_t> generation_map(
              { {0, 100}, {1, 100}, {2, 100}, {3, 10}, {4, 10} });
  
          std::map<uint32_t, uint32_t> generation_map(
              {
                  {0, 100}, {1, 100},
                  {2, 100}, {3, 10},
                  {4, 10}
              });
  
          // Examples for non-optimal manual layout. The lines should be broken
          // after the '(' to get decent layout.
          score::generation_storage_in::coder_type::factory factory(symbol_size,
                                                                    generation_size);
  
          boost::asio::ip::multicast::join_group option(addr,
                                                        score::manual_sender::address_type());
      }
  
      // Assignments and arithmetics
      void assignments()
      {
          m_pep = m_pep * std::pow(base, losses + 1.0) +
                  (1.0 - std::pow(base, losses));
  
          m_worst =
              (m_worst) ? std::max(*m_worst, s.m_rank) : s.m_rank;
  
          bool binary_ext_fields =
              std::is_same<field_type, fifi::binary4>::value ||
              std::is_same<field_type, fifi::binary8>::value;
  
          double time = static_cast<double>(
              boost::chrono::duration_cast<boost::chrono::microseconds>(
                  m_total_stop-m_total_start).count());
  
          statistics iter = calculate_statistics(iterations.cbegin(),
                                                 iterations.cend());
  
          bool result = std::equal(input_buffer.begin(), input_buffer.end(),
                                   output_buffer.begin());
  
          m_socket->async_receive_from(
              looooooooooooooooong_function_name1(alpha) <
              looooooooooooooooong_function_name2(beta));
  
          std::shared_ptr<endpoint_type> ep =
              std::make_shared<endpoint_type>();
  
          using rlnc_decoder = kodo_rlnc::full_vector_decoder<
                               fifi::binary, fifi::binary4, fifi::binary8>;
  
          uint8_t constant_matrix[3][3] =
              {
                  {1, 2, 3},
                  {5, 6, 7},
                  {53, 71, 42}
              };
  
          expected_coefficients =
              { 95, 203, 243, 46, 187, 199, 153, 152, 39, 114 };
  
          EXXXXXXXXECT_EQ(1u, stack.m_send.calls()) <<
              "Only one packet be send as " <<
              "io service is not run yet";
  
          out << "\t\t" << "dest = " << ((uintptr_t) std::get<0>(v))
              << " src = " << ((uintptr_t) std::get<1>(v))
              << " length = " << ((uint32_t) std::get<2>(v)) << std::endl;
  
          std::cout << "This is a very looooooong line for this Hello World! " <<
                    "string string" << num << std::endl;
      }
  
      // Return statements
      void return_statements()
      {
          return  m_pep * std::pow(base, losses + 1.0) +
                  (1.0 - std::pow(base, losses));
  
          return looooooooooooooooong_function_name(
              alpha + beta);
  
          return detail::easy_bind(
              detail::build_indices<sizeof...(Args)>(),
              mf, std::forward<Args>(args)...);
      }
  
  
      // Control flow and special blocks
      void blocks()
      {
          {
              max_value = *std::max_element(std::begin(m_container),
                                            std::end(m_container));
  
              m_redundancy_estimator.sample(
                  (1.0 + m_redundancy_estimator.estimate()) *
                  m_generation_size() / m_worst.get() - 1.0);
  
              bool alpha = beta +
                           gamma;
  
              return beta +
                     gamma;
          }
  
          if (coffee_pot == full &&
              second_condition::value &&
              third_condition::value)
          {
              continue;
          }
  
          while (foundAssignmentOp->length() <
                 foundNonAssignmentOp->length())
          {
              foundAssignmentOp = NULL;
          }
  
          for (const auto& item : m_snack_list)
          {
              item.write(writer, m_current_generation);
          }
  
          for (auto it = stored_snacks.lower_bound(feedback_generation - rtt);
               it != stored_snacks.end(); ++it)
          {
              lowest_rank = std::min(it->second, lowest_rank);
          }
  
          switch (other.m_type)
          {
          case class_type::object:
              m_internal.m_map =
                  new json::object_type(
                      other.m_internal.m_map->begin(),
                      other.m_internal.m_map->end());
              break;
          default:
              // Something
              break;
          }
  
          try
          {
              my_function();
          }
          catch (const std::exception& e)
          {
              // handles std::exception
          }
          catch (...)
          {
              // handles int or std::string or any other unrelated type
          }
  
          // Alignment for commas
          int a, b, c,
              d, e, f;
  
          // This is a block with an arbitrary macro header
          RUN
          {
              max_value = *std::max_element(std::begin(m_container),
                                            std::end(m_container));
  
              m_redundancy_estimator.sample(
                  (1.0 + m_redundancy_estimator.estimate()) *
                  m_generation_size() / m_worst.get() - 1.0);
  
              bool alpha = beta +
                           gamma;
  
              return beta +
                     gamma;
          }
      }
  
  
      // Lambda functions
      void lambda_functions()
      {
          // Standalone lambdas
  
          auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
          {
              EXPECT_TRUE((bool) o);
              ++recycled;
          };
  
          auto callback = [function](const std::string& zone,
                                     const std::string& message)
          {
              boost::python::call<void>(function, zone, message);
          };
  
          auto callback = [function](
              const std::string& zone, const std::string& message)
          {
              boost::python::call<void>(function, zone, message);
          };
  
          auto compare = [](const parameter& a, const parameter& b) -> bool
          {
              if (std::get<0>(a) != std::get<0>(b))
                  return false;
          };
  
          // Single-line lambdas
  
          std::function<uint32_t()> m_delay_generator =
              []() { return 0; };
  
          m_output_queue.insert(m_output_queue.begin(),
                                queue_item(repair, []() {}));
  
          std::generate(data.begin(), data.end(),
                        [&]() { return randval(engine); });
  
          in.fetch_data_ready(
              [&](std::vector<uint8_t>& cb) { fetch_data_ready_stub(cb); });
  
          // Lambda blocks as function arguments
  
          sender.flush([&io]()
          {
              io.stop();
              std::cout << "IO service stopped." << std::endl;
          });
  
          s.write_data(buffer, [&]()
          {
              io.post(write_data_callback);
          });
  
          m_io_thread = std::make_shared<std::thread>([&]
          {
              m_io_service.run();
          });
  
          auto cmp = stub::make_compare([](const cup& c)->bool
          {
              return c.m_volume == 2.3;
          });
  
          // Lambda within a lambda
  
          deleter = [](kodoc_factory_t factory)
          {
              kodoc_delete_factory(factory);
  
              auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
              {
                  EXPECT_TRUE((bool) o);
                  ++recycled;
              };
          }
      }
  
      // Standalone template expressions
      void standalone_templates()
      {
          run_test_basic_api<
              // Line 1
              Encoder<fifi::binary>,
              // Line 2
              Decoder<fifi::binary>
          >(symbols, symbol_size);
  
          parser<
              box::moov<parser<
                  box::trak<parser<
                      box::mdia<parser<
                          box::hdlr,
                          box::mdhd
                      >>
                  >>
              >>
          > parser;
  
          {
              SCOPED_TRACE(testing::Message() << "field = binary");
              run_test_basic_api<
                  Encoder<fifi::binary>,
                  // Line 2
                  Decoder<fifi::binary>
              >(symbols, symbol_size);
          }
      }
  
  
  protected:
  
      // Member variables
  
      stub::function<bool(uint32_t)> is_symbol_partially_decoded;
  
      std::function<void(const std::vector<uint8_t>&)> m_write_symbol_callback;
  
      stub::function<const uint8_t*(uint32_t)> coefficient_vector_data;
  
      stub::function<uint32_t, const storage::const_storage> copy_into_symbol;
  
      stub::function<
          void(uint8_t**, const uint8_t**, uint8_t**, uint32_t, uint32_t)
      > m_vector_dot_product;
  
      stub::function<
          void (uint8_t*, const uint8_t*, value_type, uint32_t)
      > multiply_add;
  };
  
  // gtest macros
  
  INSTANTIATE_TEST_CASE_P(/* symbol_size */,
                          test_message_serialize_parse_param,
                          ::testing::Values(/*4u, 10U, 15U, 30U,*/
                              150U, 300U, 500U,
                              1500U, 3000U, 5000U));
  
  INSTANTIATE_TEST_CASE_P(
      /* symbol_size */,
      test_message_serialize_parse_param,
      ::testing::Values(
          /*4u, 10U, 15U, 30U,*/
          150U, 300U, 500U,
          1500U, 3000U, 5000U));
  
  // Main function body
  
  int main(int argc, const char* argv[])
  {
      uint16_t num = 42;
  
      auto recycle = [&recycled](std::shared_ptr<dummy_two> o)
      {
          EXPECT_TRUE((bool) o);
          ++recycled;
      };
  
      std::vector<int> v = {0, 1, 2, 3, 4, 5};
  
      std::vector<uint8_t> data =
          {
              0x67, 0x42, 0x00, 0x0A, 0xF8, 0x41, 0xA2
          };
  
      // insert code here...
      std::cout << "This is a very loooooooooong line for this Hello World! "
                << num << std::endl;
  
      for (int& i : v)
          std::cout << i << ' ';
  
      return 0;
  }
  