#include <type_traits>
#include <iostream>
 
template<class C, class T = int>
using EnableIf = typename std::enable_if<C::value, T>::type;
 
template<int N, int M>
struct is_multiple_of : std::integral_constant<bool, N % M == 0>{};
 
template<unsigned I> struct choice : choice<I+1>{};
template<> struct choice<10>{};
 
struct otherwise{ otherwise(...){} };
 
struct select_overload : choice<0>{};
 
template<unsigned N, EnableIf<is_multiple_of<N, 15>>...>
void print_fizzbuzz(choice<0>){ std::cout << "fizzbuzz\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 21>>...>
void print_fizzbuzz(choice<1>){ std::cout << "fizzbeep\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 33>>...>
void print_fizzbuzz(choice<2>){ std::cout << "fizznarf\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 35>>...>
void print_fizzbuzz(choice<3>){ std::cout << "buzzbeep\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 55>>...>
void print_fizzbuzz(choice<4>){ std::cout << "buzznarf\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 77>>...>
void print_fizzbuzz(choice<5>){ std::cout << "beepnarf\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 3>>...>
void print_fizzbuzz(choice<6>){ std::cout << "fizz\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 5>>...>
void print_fizzbuzz(choice<7>){ std::cout << "buzz\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 7>>...>
void print_fizzbuzz(choice<8>){ std::cout << "beep\n"; }
 
template<unsigned N, EnableIf<is_multiple_of<N, 11>>...>
void print_fizzbuzz(choice<9>){ std::cout << "narf\n"; }
 
// we stay with the ellipsis for the general case, so we
// don't have to adjust anything if new overloads are added
template<unsigned N>
void print_fizzbuzz(otherwise){ std::cout << N << "\n"; }
 
template<unsigned N = 1>
void do_fizzbuzz(){
    print_fizzbuzz<N>(select_overload{});
    do_fizzbuzz<N+1>();
}
 
template<>
void do_fizzbuzz<100>(){
    print_fizzbuzz<100>(select_overload{});
}
 
int main(){
  do_fizzbuzz();
}

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