A>#define SUM(a,b) (a)+(b)
A>

#include <iostream>

#define SUM(a,b) (a)+(b)

int main() {
    std::cout << SUM(1, 1) * 10 << std::endl;
}

SP>sum(std::string{""}, "abc");
SP>sum(0, 1.0);
SP>

#include <iostream>

template <typename T, typename...X>
decltype(auto) sum(T&& t, X&&...x)
requires requires {(std::forward<T>(t) + ... + std::forward<X>(x));}
{
    return (std::forward<T>(t) + ... + std::forward<X>(x));
}

int main() {
    std::cout << sum("Hello", std::string(", World"), '!') << std::endl;
}

#include <iostream>

auto sum(const auto& t, const auto&...x)
requires requires {(t + ... + x);}
{
    return (t + ... + x);
}

int main() {
    std::cout << sum("Hello", std::string(", World"), '!') << std::endl;
}

A>#define SUM(a,b) (a)+(b)
A>

std::cout << SUM(2, 2) * 2 << std::endl;

//Problem 2: what is wrong here? Plz fix.

enum class Mode{ way, no_way };

inline Mode GetMode()
{
  return Mode::no_way;
}


struct X
{
      static bool AmIM()
      {
#ifdef M_D_C
          bool res = true;
#else
          bool res = false;
#endif
          return res;
      }

      static bool isM_D_C_And_Way()
      {
          return (AmIM && GetMode() == Mode::way);
      }
};

_>>>#define SUM(a,b) a+b

#include <iostream>

#define SUM(a,b) a+b

int main() {
    std::cout << SUM(1<<1, 1) << std::endl;
}

_>>#define SUM(a,b) a+b
_>>

_>>

#define SUM(a,b) (a)+(b)

struct Base
{
    virtual void foo() const { std::cout << "base\n"; }
};

struct Derived: Base {
    virtual void foo() { std::cout << "derived\n"; }
    private: std::string trash {"123456789123456789"};
};

int main() {
    std::vector<Base> vec;
    vec.push_back(Derived{});
    for(const auto el: vec) {
        el.foo();
    }
}

sum(std::string{""}, "abc");
sum(0, 1.0);

void duplicate(std::vector<int>& v)
{
  size_t i = 0;
  size_t count = v.size();
  for (auto const& e : v)
  {
    if (i == count)
      break;
    v.push_back(e);
    i++;
  }
}

#define SUM(a,b) a+b

#define SUM(V,Y) ((V)+(Y))

int mean3(int a,int b,int c) { return (a+b+c)/3; }

for (int i = 0; i < 10; i++)
    std::cout << 1'000'000'000*i << endl;

R>Так норм?

template<typename T1, typename T2>
auto sum(T1 v1, T2 v2) {
    return v1 + v2;
}

template<typename T>
T sum(T v1, T v2) {
    return v1 + v2;
}

_>Внесём еще правок

_>#define SUM(V,Y) ((V)+(Y))
_>

#define MIN(V,Y) ((V)<(Y) ? (V) : (Y))
// . . .
MIN(++a, ++b)

SP>>sum(std::string{""}, "abc");
SP>>sum(0, 1.0);
SP>>

R>#include <iostream>

R>template <typename T, typename...X>
R>decltype(auto) sum(T&& t, X&&...x)
R>requires requires {(std::forward<T>(t) + ... + std::forward<X>(x));}
R>{
R>    return (std::forward<T>(t) + ... + std::forward<X>(x));
R>}

R>int main() {
R>    std::cout << sum("Hello", std::string(", World"), '!') << std::endl;
R>}
R>

R>Так норм?

  std::cout << sum("1234567890", 'a') << std::endl;

1. Слог образует гласный звук:
    сте-на, ба-ран (с-тена, бара-н — неправильно).

2. Слог начинается с согласного, который стоит перед гласной:
    мо-ло-ко, ко-ра (мол-око, кор-а — неправильно).

3. Буквы ь, ъ (которые не означают звуков), й нельзя отрывать от предыдущего слога:
    лай-ка, конь-ки, подъ-езд (ла-йка, кон-ьки, под-ъезд — неправильно).

4. Глухие согласные отходят к следующему слогу:
    то-чка, мо-шка (в традиционной школе верно также: точ-ка, мош-ка).

5. Звонкие согласные [й], [р], [р’], [л], [л’], [м], [м’], [н], [н’] с последующим шумным согласным отходят к предыдущему слогу:
    кор-ка, бул-ка (в традиционной школе верно также: ко-рка, бу-лка).

6. Согласные буквы, образующие один звук, нельзя разносить в разные слоги. Один звук образуют сочетания зж [ж:], тся, ться [ц:].
    у-е-зжать, но-си-тся, де-ла-ться (в традиционной школе верно также: у-ез-жать, но-сит-ся, де-лать-ся).

7. Сдвоенные согласные в середине слова относят к следующему слогу:
    кла-ссный, хо-ккей, те-ннис (в традиционной школе верно также: клас-сный, хок-кей, тен-нис).

Слоги делятся по восходящей звучности. Каждый звук имеет звучность от 1 до 4: 4 — гласные, 3 — сонорные, 2 — шумные звонкие, 1 — шумные глухие. 

8. Конец слога должен быть с максимальной звучностью (цифра 4):
    ко-ле-со (14-34-14), ко-мпью-тер (14-31 4-143).

9. Сонорные между гласными относят к следующему слогу: ка-рман (14-3343). Допускается вариант: кар-ман (ошибки не будет).
    Если есть сочетание сонорного и шумного, то раздел ставится между ними: пар-та (143-14).

10. Й всегда остается с предыдущим слогом: тай-на (143-34).

#include <iostream>

int main()
{
    signed char ch = -0xA;
    std::cout << "ch = " << 0 + ch << '\n';
}

for (int i = 0; i < 10; i++)
    std::cout << 1000000000*i << endl;

_NN>void duplicate(std::vector<int>& v)
_NN>{
_NN>  size_t i = 0;
_NN>  size_t count = v.size();
_NN>  for (auto const& e : v)
_NN>  {
_NN>    if (i == count)
_NN>      break;
_NN>    v.push_back(e);
_NN>    i++;
_NN>  }
_NN>}
_NN>

v.push_back(v[0])