//
// Copyright (c) 2012-2016 Krzysztof Jusiak (krzysztof at jusiak dot net)
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//
#include <memory>
#include <boost/di.hpp>

namespace di = boost::di;

struct x00 {
  BOOST_DI_INJECT(x00) {}
};
struct x01 {
  BOOST_DI_INJECT(x01) {}
};
struct x02 {
  BOOST_DI_INJECT(x02) {}
};
struct x03 {
  BOOST_DI_INJECT(x03) {}
};
struct x04 {
  BOOST_DI_INJECT(x04) {}
};
struct x05 {
  BOOST_DI_INJECT(x05) {}
};
struct x06 {
  BOOST_DI_INJECT(x06) {}
};
struct x07 {
  BOOST_DI_INJECT(x07) {}
};
struct x08 {
  BOOST_DI_INJECT(x08) {}
};
struct x09 {
  BOOST_DI_INJECT(x09) {}
};
struct x10 {
  BOOST_DI_INJECT(x10) {}
};
struct x11 {
  BOOST_DI_INJECT(x11) {}
};
struct x12 {
  BOOST_DI_INJECT(x12) {}
};
struct x13 {
  BOOST_DI_INJECT(x13) {}
};
struct x14 {
  BOOST_DI_INJECT(x14) {}
};
struct x15 {
  BOOST_DI_INJECT(x15) {}
};
struct x16 {
  BOOST_DI_INJECT(x16) {}
};
struct x17 {
  BOOST_DI_INJECT(x17) {}
};
struct x18 {
  BOOST_DI_INJECT(x18) {}
};
struct x19 {
  BOOST_DI_INJECT(x19) {}
};
struct x20 {
  BOOST_DI_INJECT(x20) {}
};
struct x21 {
  BOOST_DI_INJECT(x21) {}
};
struct x22 {
  BOOST_DI_INJECT(x22) {}
};
struct x23 {
  BOOST_DI_INJECT(x23) {}
};
struct x24 {
  BOOST_DI_INJECT(x24) {}
};
struct x25 {
  BOOST_DI_INJECT(x25) {}
};
struct x26 {
  BOOST_DI_INJECT(x26) {}
};
struct x27 {
  BOOST_DI_INJECT(x27) {}
};
struct x28 {
  BOOST_DI_INJECT(x28) {}
};
struct x29 {
  BOOST_DI_INJECT(x29) {}
};
struct x30 {
  BOOST_DI_INJECT(x30) {}
};
struct x31 {
  BOOST_DI_INJECT(x31) {}
};
struct x32 {
  BOOST_DI_INJECT(x32) {}
};
struct x33 {
  BOOST_DI_INJECT(x33) {}
};
struct x34 {
  BOOST_DI_INJECT(x34) {}
};
struct x35 {
  BOOST_DI_INJECT(x35) {}
};
struct x36 {
  BOOST_DI_INJECT(x36) {}
};
struct x37 {
  BOOST_DI_INJECT(x37) {}
};
struct x38 {
  BOOST_DI_INJECT(x38) {}
};
struct x39 {
  BOOST_DI_INJECT(x39) {}
};
struct x40 {
  BOOST_DI_INJECT(x40) {}
};
struct x41 {
  BOOST_DI_INJECT(x41) {}
};
struct x42 {
  BOOST_DI_INJECT(x42) {}
};
struct x43 {
  BOOST_DI_INJECT(x43) {}
};
struct x44 {
  BOOST_DI_INJECT(x44) {}
};
struct x45 {
  BOOST_DI_INJECT(x45) {}
};
struct x46 {
  BOOST_DI_INJECT(x46) {}
};
struct x47 {
  BOOST_DI_INJECT(x47) {}
};
struct x48 {
  BOOST_DI_INJECT(x48) {}
};
struct x49 {
  BOOST_DI_INJECT(x49) {}
};
struct x50 {
  BOOST_DI_INJECT(x50) {}
};
struct x51 {
  BOOST_DI_INJECT(x51) {}
};
struct x52 {
  BOOST_DI_INJECT(x52) {}
};
struct x53 {
  BOOST_DI_INJECT(x53) {}
};
struct x54 {
  BOOST_DI_INJECT(x54) {}
};
struct x55 {
  BOOST_DI_INJECT(x55) {}
};
struct x56 {
  BOOST_DI_INJECT(x56) {}
};
struct x57 {
  BOOST_DI_INJECT(x57) {}
};
struct x58 {
  BOOST_DI_INJECT(x58) {}
};
struct x59 {
  BOOST_DI_INJECT(x59) {}
};
struct x60 {
  BOOST_DI_INJECT(x60) {}
};
struct x61 {
  BOOST_DI_INJECT(x61) {}
};
struct x62 {
  BOOST_DI_INJECT(x62) {}
};
struct x63 {
  BOOST_DI_INJECT(x63) {}
};
struct x64 {
  BOOST_DI_INJECT(x64) {}
};
struct x65 {
  BOOST_DI_INJECT(x65) {}
};
struct x66 {
  BOOST_DI_INJECT(x66) {}
};
struct x67 {
  BOOST_DI_INJECT(x67) {}
};
struct x68 {
  BOOST_DI_INJECT(x68) {}
};
struct x69 {
  BOOST_DI_INJECT(x69) {}
};
struct x70 {
  BOOST_DI_INJECT(x70) {}
};
struct x71 {
  BOOST_DI_INJECT(x71) {}
};
struct x72 {
  BOOST_DI_INJECT(x72) {}
};
struct x73 {
  BOOST_DI_INJECT(x73) {}
};
struct x74 {
  BOOST_DI_INJECT(x74) {}
};
struct x75 {
  BOOST_DI_INJECT(x75) {}
};
struct x76 {
  BOOST_DI_INJECT(x76) {}
};
struct x77 {
  BOOST_DI_INJECT(x77) {}
};
struct x78 {
  BOOST_DI_INJECT(x78) {}
};
struct x79 {
  BOOST_DI_INJECT(x79) {}
};
struct x80 {
  BOOST_DI_INJECT(x80) {}
};
struct x81 {
  BOOST_DI_INJECT(x81) {}
};
struct x82 {
  BOOST_DI_INJECT(x82) {}
};
struct x83 {
  BOOST_DI_INJECT(x83) {}
};
struct x84 {
  BOOST_DI_INJECT(x84) {}
};
struct x85 {
  BOOST_DI_INJECT(x85) {}
};
struct x86 {
  BOOST_DI_INJECT(x86) {}
};
struct x87 {
  BOOST_DI_INJECT(x87) {}
};
struct x88 {
  BOOST_DI_INJECT(x88) {}
};
struct x89 {
  BOOST_DI_INJECT(x89) {}
};
struct x90 {
  BOOST_DI_INJECT(x90) {}
};
struct x91 {
  BOOST_DI_INJECT(x91) {}
};
struct x92 {
  BOOST_DI_INJECT(x92) {}
};
struct x93 {
  BOOST_DI_INJECT(x93) {}
};
struct x94 {
  BOOST_DI_INJECT(x94) {}
};
struct x95 {
  BOOST_DI_INJECT(x95) {}
};
struct x96 {
  BOOST_DI_INJECT(x96) {}
};
struct x97 {
  BOOST_DI_INJECT(x97) {}
};
struct x98 {
  BOOST_DI_INJECT(x98) {}
};
struct x99 {
  BOOST_DI_INJECT(x99) {}
};

struct y00 {
  BOOST_DI_INJECT(y00) {}
};
struct y01 {
  BOOST_DI_INJECT(y01, y00) {}
};
struct y02 {
  BOOST_DI_INJECT(y02, y00, y01) {}
};
struct y03 {
  BOOST_DI_INJECT(y03, y00, y01, y02) {}
};
struct y04 {
  BOOST_DI_INJECT(y04, y00, y01, y02, y03) {}
};
struct y05 {
  BOOST_DI_INJECT(y05, y00, y01, y02, y03, y04) {}
};
struct y06 {
  BOOST_DI_INJECT(y06, y00, y01, y02, y03, y04, y05) {}
};
struct y07 {
  BOOST_DI_INJECT(y07, y00, y01, y02, y03, y04, y05, y06) {}
};
struct y08 {
  BOOST_DI_INJECT(y08, y00, y01, y02, y03, y04, y05, y06, y07) {}
};
struct y09 {
  BOOST_DI_INJECT(y09, y00, y01, y02, y03, y04, y05, y06, y07, y08) {}
};
struct y10 {
  BOOST_DI_INJECT(y10, y00, y01, y02, y03, y04, y05, y06, y07, y08, y09) {}
};
struct y11 {
  BOOST_DI_INJECT(y11, y01, y02, y03, y04, y05, y06, y07, y08, y09, y10) {}
};
struct y12 {
  BOOST_DI_INJECT(y12, y02, y03, y04, y05, y06, y07, y08, y09, y10, y11) {}
};
struct y13 {
  BOOST_DI_INJECT(y13, y03, y04, y05, y06, y07, y08, y09, y10, y11, y12) {}
};
struct y14 {
  BOOST_DI_INJECT(y14, y04, y05, y06, y07, y08, y09, y10, y11, y12, y13) {}
};
struct y15 {
  BOOST_DI_INJECT(y15, y05, y06, y07, y08, y09, y10, y11, y12, y13, y14) {}
};
struct y16 {
  BOOST_DI_INJECT(y16, y06, y07, y08, y09, y10, y11, y12, y13, y14, y15) {}
};
struct y17 {
  BOOST_DI_INJECT(y17, y07, y08, y09, y10, y11, y12, y13, y14, y15, y16) {}
};
struct y18 {
  BOOST_DI_INJECT(y18, y08, y09, y10, y11, y12, y13, y14, y15, y16, y17) {}
};
struct y19 {
  BOOST_DI_INJECT(y19, y09, y10, y11, y12, y13, y14, y15, y16, y17, y18) {}
};
struct y20 {
  BOOST_DI_INJECT(y20, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19) {}
};
struct y21 {
  BOOST_DI_INJECT(y21, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20) {}
};
struct y22 {
  BOOST_DI_INJECT(y22, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21) {}
};
struct y23 {
  BOOST_DI_INJECT(y23, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22) {}
};
struct y24 {
  BOOST_DI_INJECT(y24, y14, y15, y16, y17, y18, y19, y20, y21, y22, y23) {}
};
struct y25 {
  BOOST_DI_INJECT(y25, y15, y16, y17, y18, y19, y20, y21, y22, y23, y24) {}
};
struct y26 {
  BOOST_DI_INJECT(y26, y16, y17, y18, y19, y20, y21, y22, y23, y24, y25) {}
};
struct y27 {
  BOOST_DI_INJECT(y27, y17, y18, y19, y20, y21, y22, y23, y24, y25, y26) {}
};
struct y28 {
  BOOST_DI_INJECT(y28, y18, y19, y20, y21, y22, y23, y24, y25, y26, y27) {}
};
struct y29 {
  BOOST_DI_INJECT(y29, y19, y20, y21, y22, y23, y24, y25, y26, y27, y28) {}
};
struct y30 {
  BOOST_DI_INJECT(y30, y20, y21, y22, y23, y24, y25, y26, y27, y28, y29) {}
};
struct y31 {
  BOOST_DI_INJECT(y31, y21, y22, y23, y24, y25, y26, y27, y28, y29, y30) {}
};
struct y32 {
  BOOST_DI_INJECT(y32, y22, y23, y24, y25, y26, y27, y28, y29, y30, y31) {}
};
struct y33 {
  BOOST_DI_INJECT(y33, y23, y24, y25, y26, y27, y28, y29, y30, y31, y32) {}
};
struct y34 {
  BOOST_DI_INJECT(y34, y24, y25, y26, y27, y28, y29, y30, y31, y32, y33) {}
};
struct y35 {
  BOOST_DI_INJECT(y35, y25, y26, y27, y28, y29, y30, y31, y32, y33, y34) {}
};
struct y36 {
  BOOST_DI_INJECT(y36, y26, y27, y28, y29, y30, y31, y32, y33, y34, y35) {}
};
struct y37 {
  BOOST_DI_INJECT(y37, y27, y28, y29, y30, y31, y32, y33, y34, y35, y36) {}
};
struct y38 {
  BOOST_DI_INJECT(y38, y28, y29, y30, y31, y32, y33, y34, y35, y36, y37) {}
};
struct y39 {
  BOOST_DI_INJECT(y39, y29, y30, y31, y32, y33, y34, y35, y36, y37, y38) {}
};
struct y40 {
  BOOST_DI_INJECT(y40, y30, y31, y32, y33, y34, y35, y36, y37, y38, y39) {}
};
struct y41 {
  BOOST_DI_INJECT(y41, y31, y32, y33, y34, y35, y36, y37, y38, y39, y40) {}
};
struct y42 {
  BOOST_DI_INJECT(y42, y32, y33, y34, y35, y36, y37, y38, y39, y40, y41) {}
};
struct y43 {
  BOOST_DI_INJECT(y43, y33, y34, y35, y36, y37, y38, y39, y40, y41, y42) {}
};
struct y44 {
  BOOST_DI_INJECT(y44, y34, y35, y36, y37, y38, y39, y40, y41, y42, y43) {}
};
struct y45 {
  BOOST_DI_INJECT(y45, y35, y36, y37, y38, y39, y40, y41, y42, y43, y44) {}
};
struct y46 {
  BOOST_DI_INJECT(y46, y36, y37, y38, y39, y40, y41, y42, y43, y44, y45) {}
};
struct y47 {
  BOOST_DI_INJECT(y47, y37, y38, y39, y40, y41, y42, y43, y44, y45, y46) {}
};
struct y48 {
  BOOST_DI_INJECT(y48, y38, y39, y40, y41, y42, y43, y44, y45, y46, y47) {}
};
struct y49 {
  BOOST_DI_INJECT(y49, y39, y40, y41, y42, y43, y44, y45, y46, y47, y48) {}
};
struct y50 {
  BOOST_DI_INJECT(y50, y40, y41, y42, y43, y44, y45, y46, y47, y48, y49) {}
};
struct y51 {
  BOOST_DI_INJECT(y51, y41, y42, y43, y44, y45, y46, y47, y48, y49, y50) {}
};
struct y52 {
  BOOST_DI_INJECT(y52, y42, y43, y44, y45, y46, y47, y48, y49, y50, y51) {}
};
struct y53 {
  BOOST_DI_INJECT(y53, y43, y44, y45, y46, y47, y48, y49, y50, y51, y52) {}
};
struct y54 {
  BOOST_DI_INJECT(y54, y44, y45, y46, y47, y48, y49, y50, y51, y52, y53) {}
};
struct y55 {
  BOOST_DI_INJECT(y55, y45, y46, y47, y48, y49, y50, y51, y52, y53, y54) {}
};
struct y56 {
  BOOST_DI_INJECT(y56, y46, y47, y48, y49, y50, y51, y52, y53, y54, y55) {}
};
struct y57 {
  BOOST_DI_INJECT(y57, y47, y48, y49, y50, y51, y52, y53, y54, y55, y56) {}
};
struct y58 {
  BOOST_DI_INJECT(y58, y48, y49, y50, y51, y52, y53, y54, y55, y56, y57) {}
};
struct y59 {
  BOOST_DI_INJECT(y59, y49, y50, y51, y52, y53, y54, y55, y56, y57, y58) {}
};
struct y60 {
  BOOST_DI_INJECT(y60, y50, y51, y52, y53, y54, y55, y56, y57, y58, y59) {}
};
struct y61 {
  BOOST_DI_INJECT(y61, y51, y52, y53, y54, y55, y56, y57, y58, y59, y60) {}
};
struct y62 {
  BOOST_DI_INJECT(y62, y52, y53, y54, y55, y56, y57, y58, y59, y60, y61) {}
};
struct y63 {
  BOOST_DI_INJECT(y63, y53, y54, y55, y56, y57, y58, y59, y60, y61, y62) {}
};
struct y64 {
  BOOST_DI_INJECT(y64, y54, y55, y56, y57, y58, y59, y60, y61, y62, y63) {}
};
struct y65 {
  BOOST_DI_INJECT(y65, y55, y56, y57, y58, y59, y60, y61, y62, y63, y64) {}
};
struct y66 {
  BOOST_DI_INJECT(y66, y56, y57, y58, y59, y60, y61, y62, y63, y64, y65) {}
};
struct y67 {
  BOOST_DI_INJECT(y67, y57, y58, y59, y60, y61, y62, y63, y64, y65, y66) {}
};
struct y68 {
  BOOST_DI_INJECT(y68, y58, y59, y60, y61, y62, y63, y64, y65, y66, y67) {}
};
struct y69 {
  BOOST_DI_INJECT(y69, y59, y60, y61, y62, y63, y64, y65, y66, y67, y68) {}
};
struct y70 {
  BOOST_DI_INJECT(y70, y60, y61, y62, y63, y64, y65, y66, y67, y68, y69) {}
};
struct y71 {
  BOOST_DI_INJECT(y71, y61, y62, y63, y64, y65, y66, y67, y68, y69, y70) {}
};
struct y72 {
  BOOST_DI_INJECT(y72, y62, y63, y64, y65, y66, y67, y68, y69, y70, y71) {}
};
struct y73 {
  BOOST_DI_INJECT(y73, y63, y64, y65, y66, y67, y68, y69, y70, y71, y72) {}
};
struct y74 {
  BOOST_DI_INJECT(y74, y64, y65, y66, y67, y68, y69, y70, y71, y72, y73) {}
};
struct y75 {
  BOOST_DI_INJECT(y75, y65, y66, y67, y68, y69, y70, y71, y72, y73, y74) {}
};
struct y76 {
  BOOST_DI_INJECT(y76, y66, y67, y68, y69, y70, y71, y72, y73, y74, y75) {}
};
struct y77 {
  BOOST_DI_INJECT(y77, y67, y68, y69, y70, y71, y72, y73, y74, y75, y76) {}
};
struct y78 {
  BOOST_DI_INJECT(y78, y68, y69, y70, y71, y72, y73, y74, y75, y76, y77) {}
};
struct y79 {
  BOOST_DI_INJECT(y79, y69, y70, y71, y72, y73, y74, y75, y76, y77, y78) {}
};
struct y80 {
  BOOST_DI_INJECT(y80, y70, y71, y72, y73, y74, y75, y76, y77, y78, y79) {}
};
struct y81 {
  BOOST_DI_INJECT(y81, y71, y72, y73, y74, y75, y76, y77, y78, y79, y80) {}
};
struct y82 {
  BOOST_DI_INJECT(y82, y72, y73, y74, y75, y76, y77, y78, y79, y80, y81) {}
};
struct y83 {
  BOOST_DI_INJECT(y83, y73, y74, y75, y76, y77, y78, y79, y80, y81, y82) {}
};
struct y84 {
  BOOST_DI_INJECT(y84, y74, y75, y76, y77, y78, y79, y80, y81, y82, y83) {}
};
struct y85 {
  BOOST_DI_INJECT(y85, y75, y76, y77, y78, y79, y80, y81, y82, y83, y84) {}
};
struct y86 {
  BOOST_DI_INJECT(y86, y76, y77, y78, y79, y80, y81, y82, y83, y84, y85) {}
};
struct y87 {
  BOOST_DI_INJECT(y87, y77, y78, y79, y80, y81, y82, y83, y84, y85, y86) {}
};
struct y88 {
  BOOST_DI_INJECT(y88, y78, y79, y80, y81, y82, y83, y84, y85, y86, y87) {}
};
struct y89 {
  BOOST_DI_INJECT(y89, y79, y80, y81, y82, y83, y84, y85, y86, y87, y88) {}
};
struct y90 {
  BOOST_DI_INJECT(y90, y80, y81, y82, y83, y84, y85, y86, y87, y88, y89) {}
};
struct y91 {
  BOOST_DI_INJECT(y91, y81, y82, y83, y84, y85, y86, y87, y88, y89, y90) {}
};
struct y92 {
  BOOST_DI_INJECT(y92, y82, y83, y84, y85, y86, y87, y88, y89, y90, y91) {}
};
struct y93 {
  BOOST_DI_INJECT(y93, y83, y84, y85, y86, y87, y88, y89, y90, y91, y92) {}
};
struct y94 {
  BOOST_DI_INJECT(y94, y84, y85, y86, y87, y88, y89, y90, y91, y92, y93) {}
};
struct y95 {
  BOOST_DI_INJECT(y95, y85, y86, y87, y88, y89, y90, y91, y92, y93, y94) {}
};
struct y96 {
  BOOST_DI_INJECT(y96, y86, y87, y88, y89, y90, y91, y92, y93, y94, y95) {}
};
struct y97 {
  BOOST_DI_INJECT(y97, y87, y88, y89, y90, y91, y92, y93, y94, y95, y96) {}
};
struct y98 {
  BOOST_DI_INJECT(y98, y88, y89, y90, y91, y92, y93, y94, y95, y96, y97) {}
};
struct y99 {
  BOOST_DI_INJECT(y99, y89, y90, y91, y92, y93, y94, y95, y96, y97, y98) {}
};

struct i00 {
  virtual ~i00() noexcept = default;
  virtual void dummy() = 0;
};
struct impl00 : i00 {
  BOOST_DI_INJECT(impl00, y00, y01, y02, y03, y04, y05, y06, y07, y08, y09) {}
  void dummy() override {}
};
struct i01 {
  virtual ~i01() noexcept = default;
  virtual void dummy() = 0;
};
struct impl01 : i01 {
  BOOST_DI_INJECT(impl01, y01, y02, y03, y04, y05, y06, y07, y08, y09, y10) {}
  void dummy() override {}
};
struct i02 {
  virtual ~i02() noexcept = default;
  virtual void dummy() = 0;
};
struct impl02 : i02 {
  BOOST_DI_INJECT(impl02, y02, y03, y04, y05, y06, y07, y08, y09, y10, y11) {}
  void dummy() override {}
};
struct i03 {
  virtual ~i03() noexcept = default;
  virtual void dummy() = 0;
};
struct impl03 : i03 {
  BOOST_DI_INJECT(impl03, y03, y04, y05, y06, y07, y08, y09, y10, y11, y12) {}
  void dummy() override {}
};
struct i04 {
  virtual ~i04() noexcept = default;
  virtual void dummy() = 0;
};
struct impl04 : i04 {
  BOOST_DI_INJECT(impl04, y04, y05, y06, y07, y08, y09, y10, y11, y12, y13) {}
  void dummy() override {}
};
struct i05 {
  virtual ~i05() noexcept = default;
  virtual void dummy() = 0;
};
struct impl05 : i05 {
  BOOST_DI_INJECT(impl05, y05, y06, y07, y08, y09, y10, y11, y12, y13, y14) {}
  void dummy() override {}
};
struct i06 {
  virtual ~i06() noexcept = default;
  virtual void dummy() = 0;
};
struct impl06 : i06 {
  BOOST_DI_INJECT(impl06, y06, y07, y08, y09, y10, y11, y12, y13, y14, y15) {}
  void dummy() override {}
};
struct i07 {
  virtual ~i07() noexcept = default;
  virtual void dummy() = 0;
};
struct impl07 : i07 {
  BOOST_DI_INJECT(impl07, y07, y08, y09, y10, y11, y12, y13, y14, y15, y16) {}
  void dummy() override {}
};
struct i08 {
  virtual ~i08() noexcept = default;
  virtual void dummy() = 0;
};
struct impl08 : i08 {
  BOOST_DI_INJECT(impl08, y08, y09, y10, y11, y12, y13, y14, y15, y16, y17) {}
  void dummy() override {}
};
struct i09 {
  virtual ~i09() noexcept = default;
  virtual void dummy() = 0;
};
struct impl09 : i09 {
  BOOST_DI_INJECT(impl09, y09, y10, y11, y12, y13, y14, y15, y16, y17, y18) {}
  void dummy() override {}
};
struct i10 {
  virtual ~i10() noexcept = default;
  virtual void dummy() = 0;
};
struct impl10 : i10 {
  BOOST_DI_INJECT(impl10, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19) {}
  void dummy() override {}
};
struct i11 {
  virtual ~i11() noexcept = default;
  virtual void dummy() = 0;
};
struct impl11 : i11 {
  BOOST_DI_INJECT(impl11, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20) {}
  void dummy() override {}
};
struct i12 {
  virtual ~i12() noexcept = default;
  virtual void dummy() = 0;
};
struct impl12 : i12 {
  BOOST_DI_INJECT(impl12, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21) {}
  void dummy() override {}
};
struct i13 {
  virtual ~i13() noexcept = default;
  virtual void dummy() = 0;
};
struct impl13 : i13 {
  BOOST_DI_INJECT(impl13, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22) {}
  void dummy() override {}
};
struct i14 {
  virtual ~i14() noexcept = default;
  virtual void dummy() = 0;
};
struct impl14 : i14 {
  BOOST_DI_INJECT(impl14, y14, y15, y16, y17, y18, y19, y20, y21, y22, y23) {}
  void dummy() override {}
};
struct i15 {
  virtual ~i15() noexcept = default;
  virtual void dummy() = 0;
};
struct impl15 : i15 {
  BOOST_DI_INJECT(impl15, y15, y16, y17, y18, y19, y20, y21, y22, y23, y24) {}
  void dummy() override {}
};
struct i16 {
  virtual ~i16() noexcept = default;
  virtual void dummy() = 0;
};
struct impl16 : i16 {
  BOOST_DI_INJECT(impl16, y16, y17, y18, y19, y20, y21, y22, y23, y24, y25) {}
  void dummy() override {}
};
struct i17 {
  virtual ~i17() noexcept = default;
  virtual void dummy() = 0;
};
struct impl17 : i17 {
  BOOST_DI_INJECT(impl17, y17, y18, y19, y20, y21, y22, y23, y24, y25, y26) {}
  void dummy() override {}
};
struct i18 {
  virtual ~i18() noexcept = default;
  virtual void dummy() = 0;
};
struct impl18 : i18 {
  BOOST_DI_INJECT(impl18, y18, y19, y20, y21, y22, y23, y24, y25, y26, y27) {}
  void dummy() override {}
};
struct i19 {
  virtual ~i19() noexcept = default;
  virtual void dummy() = 0;
};
struct impl19 : i19 {
  BOOST_DI_INJECT(impl19, y19, y20, y21, y22, y23, y24, y25, y26, y27, y28) {}
  void dummy() override {}
};
struct i20 {
  virtual ~i20() noexcept = default;
  virtual void dummy() = 0;
};
struct impl20 : i20 {
  BOOST_DI_INJECT(impl20, y20, y21, y22, y23, y24, y25, y26, y27, y28, y29) {}
  void dummy() override {}
};
struct i21 {
  virtual ~i21() noexcept = default;
  virtual void dummy() = 0;
};
struct impl21 : i21 {
  BOOST_DI_INJECT(impl21, y21, y22, y23, y24, y25, y26, y27, y28, y29, y30) {}
  void dummy() override {}
};
struct i22 {
  virtual ~i22() noexcept = default;
  virtual void dummy() = 0;
};
struct impl22 : i22 {
  BOOST_DI_INJECT(impl22, y22, y23, y24, y25, y26, y27, y28, y29, y30, y31) {}
  void dummy() override {}
};
struct i23 {
  virtual ~i23() noexcept = default;
  virtual void dummy() = 0;
};
struct impl23 : i23 {
  BOOST_DI_INJECT(impl23, y23, y24, y25, y26, y27, y28, y29, y30, y31, y32) {}
  void dummy() override {}
};
struct i24 {
  virtual ~i24() noexcept = default;
  virtual void dummy() = 0;
};
struct impl24 : i24 {
  BOOST_DI_INJECT(impl24, y24, y25, y26, y27, y28, y29, y30, y31, y32, y33) {}
  void dummy() override {}
};
struct i25 {
  virtual ~i25() noexcept = default;
  virtual void dummy() = 0;
};
struct impl25 : i25 {
  BOOST_DI_INJECT(impl25, y25, y26, y27, y28, y29, y30, y31, y32, y33, y34) {}
  void dummy() override {}
};
struct i26 {
  virtual ~i26() noexcept = default;
  virtual void dummy() = 0;
};
struct impl26 : i26 {
  BOOST_DI_INJECT(impl26, y26, y27, y28, y29, y30, y31, y32, y33, y34, y35) {}
  void dummy() override {}
};
struct i27 {
  virtual ~i27() noexcept = default;
  virtual void dummy() = 0;
};
struct impl27 : i27 {
  BOOST_DI_INJECT(impl27, y27, y28, y29, y30, y31, y32, y33, y34, y35, y36) {}
  void dummy() override {}
};
struct i28 {
  virtual ~i28() noexcept = default;
  virtual void dummy() = 0;
};
struct impl28 : i28 {
  BOOST_DI_INJECT(impl28, y28, y29, y30, y31, y32, y33, y34, y35, y36, y37) {}
  void dummy() override {}
};
struct i29 {
  virtual ~i29() noexcept = default;
  virtual void dummy() = 0;
};
struct impl29 : i29 {
  BOOST_DI_INJECT(impl29, y29, y30, y31, y32, y33, y34, y35, y36, y37, y38) {}
  void dummy() override {}
};
struct i30 {
  virtual ~i30() noexcept = default;
  virtual void dummy() = 0;
};
struct impl30 : i30 {
  BOOST_DI_INJECT(impl30, y30, y31, y32, y33, y34, y35, y36, y37, y38, y39) {}
  void dummy() override {}
};
struct i31 {
  virtual ~i31() noexcept = default;
  virtual void dummy() = 0;
};
struct impl31 : i31 {
  BOOST_DI_INJECT(impl31, y31, y32, y33, y34, y35, y36, y37, y38, y39, y40) {}
  void dummy() override {}
};
struct i32 {
  virtual ~i32() noexcept = default;
  virtual void dummy() = 0;
};
struct impl32 : i32 {
  BOOST_DI_INJECT(impl32, y32, y33, y34, y35, y36, y37, y38, y39, y40, y41) {}
  void dummy() override {}
};
struct i33 {
  virtual ~i33() noexcept = default;
  virtual void dummy() = 0;
};
struct impl33 : i33 {
  BOOST_DI_INJECT(impl33, y33, y34, y35, y36, y37, y38, y39, y40, y41, y42) {}
  void dummy() override {}
};
struct i34 {
  virtual ~i34() noexcept = default;
  virtual void dummy() = 0;
};
struct impl34 : i34 {
  BOOST_DI_INJECT(impl34, y34, y35, y36, y37, y38, y39, y40, y41, y42, y43) {}
  void dummy() override {}
};
struct i35 {
  virtual ~i35() noexcept = default;
  virtual void dummy() = 0;
};
struct impl35 : i35 {
  BOOST_DI_INJECT(impl35, y35, y36, y37, y38, y39, y40, y41, y42, y43, y44) {}
  void dummy() override {}
};
struct i36 {
  virtual ~i36() noexcept = default;
  virtual void dummy() = 0;
};
struct impl36 : i36 {
  BOOST_DI_INJECT(impl36, y36, y37, y38, y39, y40, y41, y42, y43, y44, y45) {}
  void dummy() override {}
};
struct i37 {
  virtual ~i37() noexcept = default;
  virtual void dummy() = 0;
};
struct impl37 : i37 {
  BOOST_DI_INJECT(impl37, y37, y38, y39, y40, y41, y42, y43, y44, y45, y46) {}
  void dummy() override {}
};
struct i38 {
  virtual ~i38() noexcept = default;
  virtual void dummy() = 0;
};
struct impl38 : i38 {
  BOOST_DI_INJECT(impl38, y38, y39, y40, y41, y42, y43, y44, y45, y46, y47) {}
  void dummy() override {}
};
struct i39 {
  virtual ~i39() noexcept = default;
  virtual void dummy() = 0;
};
struct impl39 : i39 {
  BOOST_DI_INJECT(impl39, y39, y40, y41, y42, y43, y44, y45, y46, y47, y48) {}
  void dummy() override {}
};
struct i40 {
  virtual ~i40() noexcept = default;
  virtual void dummy() = 0;
};
struct impl40 : i40 {
  BOOST_DI_INJECT(impl40, y40, y41, y42, y43, y44, y45, y46, y47, y48, y49) {}
  void dummy() override {}
};
struct i41 {
  virtual ~i41() noexcept = default;
  virtual void dummy() = 0;
};
struct impl41 : i41 {
  BOOST_DI_INJECT(impl41, y41, y42, y43, y44, y45, y46, y47, y48, y49, y50) {}
  void dummy() override {}
};
struct i42 {
  virtual ~i42() noexcept = default;
  virtual void dummy() = 0;
};
struct impl42 : i42 {
  BOOST_DI_INJECT(impl42, y42, y43, y44, y45, y46, y47, y48, y49, y50, y51) {}
  void dummy() override {}
};
struct i43 {
  virtual ~i43() noexcept = default;
  virtual void dummy() = 0;
};
struct impl43 : i43 {
  BOOST_DI_INJECT(impl43, y43, y44, y45, y46, y47, y48, y49, y50, y51, y52) {}
  void dummy() override {}
};
struct i44 {
  virtual ~i44() noexcept = default;
  virtual void dummy() = 0;
};
struct impl44 : i44 {
  BOOST_DI_INJECT(impl44, y44, y45, y46, y47, y48, y49, y50, y51, y52, y53) {}
  void dummy() override {}
};
struct i45 {
  virtual ~i45() noexcept = default;
  virtual void dummy() = 0;
};
struct impl45 : i45 {
  BOOST_DI_INJECT(impl45, y45, y46, y47, y48, y49, y50, y51, y52, y53, y54) {}
  void dummy() override {}
};
struct i46 {
  virtual ~i46() noexcept = default;
  virtual void dummy() = 0;
};
struct impl46 : i46 {
  BOOST_DI_INJECT(impl46, y46, y47, y48, y49, y50, y51, y52, y53, y54, y55) {}
  void dummy() override {}
};
struct i47 {
  virtual ~i47() noexcept = default;
  virtual void dummy() = 0;
};
struct impl47 : i47 {
  BOOST_DI_INJECT(impl47, y47, y48, y49, y50, y51, y52, y53, y54, y55, y56) {}
  void dummy() override {}
};
struct i48 {
  virtual ~i48() noexcept = default;
  virtual void dummy() = 0;
};
struct impl48 : i48 {
  BOOST_DI_INJECT(impl48, y48, y49, y50, y51, y52, y53, y54, y55, y56, y57) {}
  void dummy() override {}
};
struct i49 {
  virtual ~i49() noexcept = default;
  virtual void dummy() = 0;
};
struct impl49 : i49 {
  BOOST_DI_INJECT(impl49, y49, y50, y51, y52, y53, y54, y55, y56, y57, y58) {}
  void dummy() override {}
};
struct i50 {
  virtual ~i50() noexcept = default;
  virtual void dummy() = 0;
};
struct impl50 : i50 {
  BOOST_DI_INJECT(impl50, y50, y51, y52, y53, y54, y55, y56, y57, y58, y59) {}
  void dummy() override {}
};
struct i51 {
  virtual ~i51() noexcept = default;
  virtual void dummy() = 0;
};
struct impl51 : i51 {
  BOOST_DI_INJECT(impl51, y51, y52, y53, y54, y55, y56, y57, y58, y59, y60) {}
  void dummy() override {}
};
struct i52 {
  virtual ~i52() noexcept = default;
  virtual void dummy() = 0;
};
struct impl52 : i52 {
  BOOST_DI_INJECT(impl52, y52, y53, y54, y55, y56, y57, y58, y59, y60, y61) {}
  void dummy() override {}
};
struct i53 {
  virtual ~i53() noexcept = default;
  virtual void dummy() = 0;
};
struct impl53 : i53 {
  BOOST_DI_INJECT(impl53, y53, y54, y55, y56, y57, y58, y59, y60, y61, y62) {}
  void dummy() override {}
};
struct i54 {
  virtual ~i54() noexcept = default;
  virtual void dummy() = 0;
};
struct impl54 : i54 {
  BOOST_DI_INJECT(impl54, y54, y55, y56, y57, y58, y59, y60, y61, y62, y63) {}
  void dummy() override {}
};
struct i55 {
  virtual ~i55() noexcept = default;
  virtual void dummy() = 0;
};
struct impl55 : i55 {
  BOOST_DI_INJECT(impl55, y55, y56, y57, y58, y59, y60, y61, y62, y63, y64) {}
  void dummy() override {}
};
struct i56 {
  virtual ~i56() noexcept = default;
  virtual void dummy() = 0;
};
struct impl56 : i56 {
  BOOST_DI_INJECT(impl56, y56, y57, y58, y59, y60, y61, y62, y63, y64, y65) {}
  void dummy() override {}
};
struct i57 {
  virtual ~i57() noexcept = default;
  virtual void dummy() = 0;
};
struct impl57 : i57 {
  BOOST_DI_INJECT(impl57, y57, y58, y59, y60, y61, y62, y63, y64, y65, y66) {}
  void dummy() override {}
};
struct i58 {
  virtual ~i58() noexcept = default;
  virtual void dummy() = 0;
};
struct impl58 : i58 {
  BOOST_DI_INJECT(impl58, y58, y59, y60, y61, y62, y63, y64, y65, y66, y67) {}
  void dummy() override {}
};
struct i59 {
  virtual ~i59() noexcept = default;
  virtual void dummy() = 0;
};
struct impl59 : i59 {
  BOOST_DI_INJECT(impl59, y59, y60, y61, y62, y63, y64, y65, y66, y67, y68) {}
  void dummy() override {}
};
struct i60 {
  virtual ~i60() noexcept = default;
  virtual void dummy() = 0;
};
struct impl60 : i60 {
  BOOST_DI_INJECT(impl60, y60, y61, y62, y63, y64, y65, y66, y67, y68, y69) {}
  void dummy() override {}
};
struct i61 {
  virtual ~i61() noexcept = default;
  virtual void dummy() = 0;
};
struct impl61 : i61 {
  BOOST_DI_INJECT(impl61, y61, y62, y63, y64, y65, y66, y67, y68, y69, y70) {}
  void dummy() override {}
};
struct i62 {
  virtual ~i62() noexcept = default;
  virtual void dummy() = 0;
};
struct impl62 : i62 {
  BOOST_DI_INJECT(impl62, y62, y63, y64, y65, y66, y67, y68, y69, y70, y71) {}
  void dummy() override {}
};
struct i63 {
  virtual ~i63() noexcept = default;
  virtual void dummy() = 0;
};
struct impl63 : i63 {
  BOOST_DI_INJECT(impl63, y63, y64, y65, y66, y67, y68, y69, y70, y71, y72) {}
  void dummy() override {}
};
struct i64 {
  virtual ~i64() noexcept = default;
  virtual void dummy() = 0;
};
struct impl64 : i64 {
  BOOST_DI_INJECT(impl64, y64, y65, y66, y67, y68, y69, y70, y71, y72, y73) {}
  void dummy() override {}
};
struct i65 {
  virtual ~i65() noexcept = default;
  virtual void dummy() = 0;
};
struct impl65 : i65 {
  BOOST_DI_INJECT(impl65, y65, y66, y67, y68, y69, y70, y71, y72, y73, y74) {}
  void dummy() override {}
};
struct i66 {
  virtual ~i66() noexcept = default;
  virtual void dummy() = 0;
};
struct impl66 : i66 {
  BOOST_DI_INJECT(impl66, y66, y67, y68, y69, y70, y71, y72, y73, y74, y75) {}
  void dummy() override {}
};
struct i67 {
  virtual ~i67() noexcept = default;
  virtual void dummy() = 0;
};
struct impl67 : i67 {
  BOOST_DI_INJECT(impl67, y67, y68, y69, y70, y71, y72, y73, y74, y75, y76) {}
  void dummy() override {}
};
struct i68 {
  virtual ~i68() noexcept = default;
  virtual void dummy() = 0;
};
struct impl68 : i68 {
  BOOST_DI_INJECT(impl68, y68, y69, y70, y71, y72, y73, y74, y75, y76, y77) {}
  void dummy() override {}
};
struct i69 {
  virtual ~i69() noexcept = default;
  virtual void dummy() = 0;
};
struct impl69 : i69 {
  BOOST_DI_INJECT(impl69, y69, y70, y71, y72, y73, y74, y75, y76, y77, y78) {}
  void dummy() override {}
};
struct i70 {
  virtual ~i70() noexcept = default;
  virtual void dummy() = 0;
};
struct impl70 : i70 {
  BOOST_DI_INJECT(impl70, y70, y71, y72, y73, y74, y75, y76, y77, y78, y79) {}
  void dummy() override {}
};
struct i71 {
  virtual ~i71() noexcept = default;
  virtual void dummy() = 0;
};
struct impl71 : i71 {
  BOOST_DI_INJECT(impl71, y71, y72, y73, y74, y75, y76, y77, y78, y79, y80) {}
  void dummy() override {}
};
struct i72 {
  virtual ~i72() noexcept = default;
  virtual void dummy() = 0;
};
struct impl72 : i72 {
  BOOST_DI_INJECT(impl72, y72, y73, y74, y75, y76, y77, y78, y79, y80, y81) {}
  void dummy() override {}
};
struct i73 {
  virtual ~i73() noexcept = default;
  virtual void dummy() = 0;
};
struct impl73 : i73 {
  BOOST_DI_INJECT(impl73, y73, y74, y75, y76, y77, y78, y79, y80, y81, y82) {}
  void dummy() override {}
};
struct i74 {
  virtual ~i74() noexcept = default;
  virtual void dummy() = 0;
};
struct impl74 : i74 {
  BOOST_DI_INJECT(impl74, y74, y75, y76, y77, y78, y79, y80, y81, y82, y83) {}
  void dummy() override {}
};
struct i75 {
  virtual ~i75() noexcept = default;
  virtual void dummy() = 0;
};
struct impl75 : i75 {
  BOOST_DI_INJECT(impl75, y75, y76, y77, y78, y79, y80, y81, y82, y83, y84) {}
  void dummy() override {}
};
struct i76 {
  virtual ~i76() noexcept = default;
  virtual void dummy() = 0;
};
struct impl76 : i76 {
  BOOST_DI_INJECT(impl76, y76, y77, y78, y79, y80, y81, y82, y83, y84, y85) {}
  void dummy() override {}
};
struct i77 {
  virtual ~i77() noexcept = default;
  virtual void dummy() = 0;
};
struct impl77 : i77 {
  BOOST_DI_INJECT(impl77, y77, y78, y79, y80, y81, y82, y83, y84, y85, y86) {}
  void dummy() override {}
};
struct i78 {
  virtual ~i78() noexcept = default;
  virtual void dummy() = 0;
};
struct impl78 : i78 {
  BOOST_DI_INJECT(impl78, y78, y79, y80, y81, y82, y83, y84, y85, y86, y87) {}
  void dummy() override {}
};
struct i79 {
  virtual ~i79() noexcept = default;
  virtual void dummy() = 0;
};
struct impl79 : i79 {
  BOOST_DI_INJECT(impl79, y79, y80, y81, y82, y83, y84, y85, y86, y87, y88) {}
  void dummy() override {}
};
struct i80 {
  virtual ~i80() noexcept = default;
  virtual void dummy() = 0;
};
struct impl80 : i80 {
  BOOST_DI_INJECT(impl80, y80, y81, y82, y83, y84, y85, y86, y87, y88, y89) {}
  void dummy() override {}
};
struct i81 {
  virtual ~i81() noexcept = default;
  virtual void dummy() = 0;
};
struct impl81 : i81 {
  BOOST_DI_INJECT(impl81, y81, y82, y83, y84, y85, y86, y87, y88, y89, y90) {}
  void dummy() override {}
};
struct i82 {
  virtual ~i82() noexcept = default;
  virtual void dummy() = 0;
};
struct impl82 : i82 {
  BOOST_DI_INJECT(impl82, y82, y83, y84, y85, y86, y87, y88, y89, y90, y91) {}
  void dummy() override {}
};
struct i83 {
  virtual ~i83() noexcept = default;
  virtual void dummy() = 0;
};
struct impl83 : i83 {
  BOOST_DI_INJECT(impl83, y83, y84, y85, y86, y87, y88, y89, y90, y91, y92) {}
  void dummy() override {}
};
struct i84 {
  virtual ~i84() noexcept = default;
  virtual void dummy() = 0;
};
struct impl84 : i84 {
  BOOST_DI_INJECT(impl84, y84, y85, y86, y87, y88, y89, y90, y91, y92, y93) {}
  void dummy() override {}
};
struct i85 {
  virtual ~i85() noexcept = default;
  virtual void dummy() = 0;
};
struct impl85 : i85 {
  BOOST_DI_INJECT(impl85, y85, y86, y87, y88, y89, y90, y91, y92, y93, y94) {}
  void dummy() override {}
};
struct i86 {
  virtual ~i86() noexcept = default;
  virtual void dummy() = 0;
};
struct impl86 : i86 {
  BOOST_DI_INJECT(impl86, y86, y87, y88, y89, y90, y91, y92, y93, y94, y95) {}
  void dummy() override {}
};
struct i87 {
  virtual ~i87() noexcept = default;
  virtual void dummy() = 0;
};
struct impl87 : i87 {
  BOOST_DI_INJECT(impl87, y87, y88, y89, y90, y91, y92, y93, y94, y95, y96) {}
  void dummy() override {}
};
struct i88 {
  virtual ~i88() noexcept = default;
  virtual void dummy() = 0;
};
struct impl88 : i88 {
  BOOST_DI_INJECT(impl88, y88, y89, y90, y91, y92, y93, y94, y95, y96, y97) {}
  void dummy() override {}
};
struct i89 {
  virtual ~i89() noexcept = default;
  virtual void dummy() = 0;
};
struct impl89 : i89 {
  BOOST_DI_INJECT(impl89, y89, y90, y91, y92, y93, y94, y95, y96, y97, y98) {}
  void dummy() override {}
};
struct i90 {
  virtual ~i90() noexcept = default;
  virtual void dummy() = 0;
};
struct impl90 : i90 {
  BOOST_DI_INJECT(impl90, y90, y91, y92, y93, y94, y95, y96, y97, y98, y99) {}
  void dummy() override {}
};
struct i91 {
  virtual ~i91() noexcept = default;
  virtual void dummy() = 0;
};
struct impl91 : i91 {
  BOOST_DI_INJECT(impl91, y91, y92, y93, y94, y95, y96, y97, y98, y99, y00) {}
  void dummy() override {}
};
struct i92 {
  virtual ~i92() noexcept = default;
  virtual void dummy() = 0;
};
struct impl92 : i92 {
  BOOST_DI_INJECT(impl92, y92, y93, y94, y95, y96, y97, y98, y99, y00, y01) {}
  void dummy() override {}
};
struct i93 {
  virtual ~i93() noexcept = default;
  virtual void dummy() = 0;
};
struct impl93 : i93 {
  BOOST_DI_INJECT(impl93, y93, y94, y95, y96, y97, y98, y99, y00, y01, y02) {}
  void dummy() override {}
};
struct i94 {
  virtual ~i94() noexcept = default;
  virtual void dummy() = 0;
};
struct impl94 : i94 {
  BOOST_DI_INJECT(impl94, y94, y95, y96, y97, y98, y99, y00, y01, y02, y03) {}
  void dummy() override {}
};
struct i95 {
  virtual ~i95() noexcept = default;
  virtual void dummy() = 0;
};
struct impl95 : i95 {
  BOOST_DI_INJECT(impl95, y95, y96, y97, y98, y99, y00, y01, y02, y03, y04) {}
  void dummy() override {}
};
struct i96 {
  virtual ~i96() noexcept = default;
  virtual void dummy() = 0;
};
struct impl96 : i96 {
  BOOST_DI_INJECT(impl96, y96, y97, y98, y99, y00, y01, y02, y03, y04, y05) {}
  void dummy() override {}
};
struct i97 {
  virtual ~i97() noexcept = default;
  virtual void dummy() = 0;
};
struct impl97 : i97 {
  BOOST_DI_INJECT(impl97, y97, y98, y99, y00, y01, y02, y03, y04, y05, y06) {}
  void dummy() override {}
};
struct i98 {
  virtual ~i98() noexcept = default;
  virtual void dummy() = 0;
};
struct impl98 : i98 {
  BOOST_DI_INJECT(impl98, y98, y99, y00, y01, y02, y03, y04, y05, y06, y07) {}
  void dummy() override {}
};
struct i99 {
  virtual ~i99() noexcept = default;
  virtual void dummy() = 0;
};
struct impl99 : i99 {
  BOOST_DI_INJECT(impl99, y99, y00, y01, y02, y03, y04, y05, y06, y07, y08) {}
  void dummy() override {}
};

struct c0 {
  BOOST_DI_INJECT(c0
#if !defined(NO_CTOR_INTERFACES1)
                  ,
                  std::unique_ptr<i00>, std::unique_ptr<i01>, std::unique_ptr<i02>, std::unique_ptr<i03>, std::unique_ptr<i04>,
                  std::unique_ptr<i05>, std::unique_ptr<i06>, std::unique_ptr<i07>, std::unique_ptr<i08>, std::unique_ptr<i09>
#endif
                  ) {
  }
};

struct c1 {
  BOOST_DI_INJECT(c1
#if !defined(NO_CTOR_INTERFACES2)
                  ,
                  std::unique_ptr<i10>, std::unique_ptr<i11>, std::unique_ptr<i12>, std::unique_ptr<i13>, std::unique_ptr<i14>,
                  std::unique_ptr<i15>, std::unique_ptr<i16>, std::unique_ptr<i17>, std::unique_ptr<i18>, std::unique_ptr<i19>
#endif
                  ) {
  }
};

struct c2 {
  BOOST_DI_INJECT(c2
#if !defined(NO_CTOR_INTERFACES3)
                  ,
                  std::unique_ptr<i20>, std::unique_ptr<i21>, std::unique_ptr<i22>, std::unique_ptr<i23>, std::unique_ptr<i24>,
                  std::unique_ptr<i25>, std::unique_ptr<i26>, std::unique_ptr<i27>, std::unique_ptr<i28>, std::unique_ptr<i29>
#endif
                  ) {
  }
};

struct c3 {
  BOOST_DI_INJECT(c3
#if !defined(NO_CTOR_INTERFACES4)
                  ,
                  std::unique_ptr<i30>, std::unique_ptr<i31>, std::unique_ptr<i32>, std::unique_ptr<i33>, std::unique_ptr<i34>,
                  std::unique_ptr<i35>, std::unique_ptr<i36>, std::unique_ptr<i37>, std::unique_ptr<i38>, std::unique_ptr<i39>
#endif
                  ) {
  }
};

struct c4 {
  BOOST_DI_INJECT(c4
#if !defined(NO_CTOR_INTERFACES5)
                  ,
                  std::unique_ptr<i40>, std::unique_ptr<i41>, std::unique_ptr<i42>, std::unique_ptr<i43>, std::unique_ptr<i44>,
                  std::unique_ptr<i45>, std::unique_ptr<i46>, std::unique_ptr<i47>, std::unique_ptr<i48>, std::unique_ptr<i49>
#endif
                  ) {
  }
};

struct c5 {
  BOOST_DI_INJECT(c5
#if !defined(NO_CTOR_INTERFACES6)
                  ,
                  std::unique_ptr<i50>, std::unique_ptr<i51>, std::unique_ptr<i52>, std::unique_ptr<i53>, std::unique_ptr<i54>,
                  std::unique_ptr<i55>, std::unique_ptr<i56>, std::unique_ptr<i57>, std::unique_ptr<i58>, std::unique_ptr<i59>
#endif
                  ) {
  }
};

struct c6 {
  BOOST_DI_INJECT(c6
#if !defined(NO_CTOR_INTERFACES7)
                  ,
                  std::unique_ptr<i60>, std::unique_ptr<i61>, std::unique_ptr<i62>, std::unique_ptr<i63>, std::unique_ptr<i64>,
                  std::unique_ptr<i65>, std::unique_ptr<i66>, std::unique_ptr<i67>, std::unique_ptr<i68>, std::unique_ptr<i69>
#endif
                  ) {
  }
};

struct c7 {
  BOOST_DI_INJECT(c7
#if !defined(NO_CTOR_INTERFACES8)
                  ,
                  std::unique_ptr<i70>, std::unique_ptr<i71>, std::unique_ptr<i72>, std::unique_ptr<i73>, std::unique_ptr<i74>,
                  std::unique_ptr<i75>, std::unique_ptr<i76>, std::unique_ptr<i77>, std::unique_ptr<i78>, std::unique_ptr<i79>
#endif
                  ) {
  }
};

struct c8 {
  BOOST_DI_INJECT(c8
#if !defined(NO_CTOR_INTERFACES9)
                  ,
                  std::unique_ptr<i80>, std::unique_ptr<i81>, std::unique_ptr<i82>, std::unique_ptr<i83>, std::unique_ptr<i84>,
                  std::unique_ptr<i85>, std::unique_ptr<i86>, std::unique_ptr<i87>, std::unique_ptr<i88>, std::unique_ptr<i89>
#endif
                  ) {
  }
};

struct c9 {
  BOOST_DI_INJECT(c9
#if !defined(NO_CTOR_INTERFACES10)
                  ,
                  std::unique_ptr<i90>, std::unique_ptr<i91>, std::unique_ptr<i92>, std::unique_ptr<i93>, std::unique_ptr<i94>,
                  std::unique_ptr<i95>, std::unique_ptr<i96>, std::unique_ptr<i97>, std::unique_ptr<i98>, std::unique_ptr<i99>
#endif
                  ) {
  }
};

struct small_complexity {
  BOOST_DI_INJECT(small_complexity, y32) {}
};
struct medium_complexity {
  BOOST_DI_INJECT(medium_complexity, y99) {}
};
struct big_complexity {
  BOOST_DI_INJECT(big_complexity, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9) {}
};

#define RETURN(...)      \
  auto m = __VA_ARGS__;  \
  using t = decltype(m); \
  struct i : t {         \
    using t::t;          \
  };                     \
  return i { static_cast<t &&>(m) }

#if defined(MODULE1)
EXPOSED_OR_AUTO(di::injector<c0>, auto) module1() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES1(di::bind<i00>().to<impl00>(), di::bind<i01>().to<impl01>(), di::bind<i02>().to<impl02>(),
                       di::bind<i03>().to<impl03>(), di::bind<i04>().to<impl04>(), di::bind<i05>().to<impl05>(),
                       di::bind<i06>().to<impl06>(), di::bind<i07>().to<impl07>(), di::bind<i08>().to<impl08>(),
                       di::bind<i09>().to<impl09>())
          BIND_OTHERS1(di::bind<x00>.in(di::unique), di::bind<x01>.in(di::unique), di::bind<x02>.in(di::unique),
                       di::bind<x03>.in(di::unique), di::bind<x04>.in(di::unique), di::bind<x05>.in(di::unique),
                       di::bind<x06>.in(di::unique), di::bind<x07>.in(di::unique), di::bind<x08>.in(di::unique),
                       di::bind<x09>.in(di::unique), di::bind<y00>.in(di::unique), di::bind<y01>.in(di::unique),
                       di::bind<y02>.in(di::unique), di::bind<y03>.in(di::unique), di::bind<y04>.in(di::unique),
                       di::bind<y05>.in(di::unique), di::bind<y06>.in(di::unique), di::bind<y07>.in(di::unique),
                       di::bind<y08>.in(di::unique), di::bind<y09>.in(di::unique))));
};
#endif

#if defined(MODULE2)
EXPOSED_OR_AUTO(di::injector<c1>, auto) module2() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES2(di::bind<i10>().to<impl10>(), di::bind<i11>().to<impl11>(), di::bind<i12>().to<impl12>(),
                       di::bind<i13>().to<impl13>(), di::bind<i14>().to<impl14>(), di::bind<i15>().to<impl15>(),
                       di::bind<i16>().to<impl16>(), di::bind<i17>().to<impl17>(), di::bind<i18>().to<impl18>(),
                       di::bind<i19>().to<impl19>())
          BIND_OTHERS2(di::bind<x10>.in(di::unique), di::bind<x11>.in(di::unique), di::bind<x12>.in(di::unique),
                       di::bind<x13>.in(di::unique), di::bind<x14>.in(di::unique), di::bind<x15>.in(di::unique),
                       di::bind<x16>.in(di::unique), di::bind<x17>.in(di::unique), di::bind<x18>.in(di::unique),
                       di::bind<x19>.in(di::unique), di::bind<y10>.in(di::unique), di::bind<y11>.in(di::unique),
                       di::bind<y12>.in(di::unique), di::bind<y13>.in(di::unique), di::bind<y14>.in(di::unique),
                       di::bind<y15>.in(di::unique), di::bind<y16>.in(di::unique), di::bind<y17>.in(di::unique),
                       di::bind<y18>.in(di::unique), di::bind<y19>.in(di::unique))));
};
#endif

#if defined(MODULE3)
EXPOSED_OR_AUTO(di::injector<c2>, auto) module3() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES3(di::bind<i20>().to<impl20>(), di::bind<i21>().to<impl21>(), di::bind<i22>().to<impl22>(),
                       di::bind<i23>().to<impl23>(), di::bind<i24>().to<impl24>(), di::bind<i25>().to<impl25>(),
                       di::bind<i26>().to<impl26>(), di::bind<i27>().to<impl27>(), di::bind<i28>().to<impl28>(),
                       di::bind<i29>().to<impl29>())
          BIND_OTHERS3(di::bind<x20>.in(di::unique), di::bind<x21>.in(di::unique), di::bind<x22>.in(di::unique),
                       di::bind<x23>.in(di::unique), di::bind<x24>.in(di::unique), di::bind<x25>.in(di::unique),
                       di::bind<x26>.in(di::unique), di::bind<x27>.in(di::unique), di::bind<x28>.in(di::unique),
                       di::bind<x29>.in(di::unique), di::bind<y20>.in(di::unique), di::bind<y21>.in(di::unique),
                       di::bind<y22>.in(di::unique), di::bind<y23>.in(di::unique), di::bind<y24>.in(di::unique),
                       di::bind<y25>.in(di::unique), di::bind<y26>.in(di::unique), di::bind<y27>.in(di::unique),
                       di::bind<y28>.in(di::unique), di::bind<y29>.in(di::unique))));
};
#endif

#if defined(MODULE4)
EXPOSED_OR_AUTO(di::injector<c3>, auto) module4() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES4(di::bind<i30>().to<impl30>(), di::bind<i31>().to<impl31>(), di::bind<i32>().to<impl32>(),
                       di::bind<i33>().to<impl33>(), di::bind<i34>().to<impl34>(), di::bind<i35>().to<impl35>(),
                       di::bind<i36>().to<impl36>(), di::bind<i37>().to<impl37>(), di::bind<i38>().to<impl38>(),
                       di::bind<i39>().to<impl39>())
          BIND_OTHERS4(di::bind<x30>.in(di::unique), di::bind<x31>.in(di::unique), di::bind<x32>.in(di::unique),
                       di::bind<x33>.in(di::unique), di::bind<x34>.in(di::unique), di::bind<x35>.in(di::unique),
                       di::bind<x36>.in(di::unique), di::bind<x37>.in(di::unique), di::bind<x38>.in(di::unique),
                       di::bind<x39>.in(di::unique), di::bind<y30>.in(di::unique), di::bind<y31>.in(di::unique),
                       di::bind<y32>.in(di::unique), di::bind<y33>.in(di::unique), di::bind<y34>.in(di::unique),
                       di::bind<y35>.in(di::unique), di::bind<y36>.in(di::unique), di::bind<y37>.in(di::unique),
                       di::bind<y38>.in(di::unique), di::bind<y39>.in(di::unique))));
};
#endif

#if defined(MODULE5)
EXPOSED_OR_AUTO(di::injector<c4>, auto) module5() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES5(di::bind<i40>().to<impl40>(), di::bind<i41>().to<impl41>(), di::bind<i42>().to<impl42>(),
                       di::bind<i43>().to<impl43>(), di::bind<i44>().to<impl44>(), di::bind<i45>().to<impl45>(),
                       di::bind<i46>().to<impl46>(), di::bind<i47>().to<impl47>(), di::bind<i48>().to<impl48>(),
                       di::bind<i49>().to<impl49>())
          BIND_OTHERS5(di::bind<x40>.in(di::unique), di::bind<x41>.in(di::unique), di::bind<x42>.in(di::unique),
                       di::bind<x43>.in(di::unique), di::bind<x44>.in(di::unique), di::bind<x45>.in(di::unique),
                       di::bind<x46>.in(di::unique), di::bind<x47>.in(di::unique), di::bind<x48>.in(di::unique),
                       di::bind<x49>.in(di::unique), di::bind<y40>.in(di::unique), di::bind<y41>.in(di::unique),
                       di::bind<y42>.in(di::unique), di::bind<y43>.in(di::unique), di::bind<y44>.in(di::unique),
                       di::bind<y45>.in(di::unique), di::bind<y46>.in(di::unique), di::bind<y47>.in(di::unique),
                       di::bind<y48>.in(di::unique), di::bind<y49>.in(di::unique))));
};
#endif

#if defined(MODULE6)
EXPOSED_OR_AUTO(di::injector<c5>, auto) module6() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES6(di::bind<i50>().to<impl50>(), di::bind<i51>().to<impl51>(), di::bind<i52>().to<impl52>(),
                       di::bind<i53>().to<impl53>(), di::bind<i54>().to<impl54>(), di::bind<i55>().to<impl55>(),
                       di::bind<i56>().to<impl56>(), di::bind<i57>().to<impl57>(), di::bind<i58>().to<impl58>(),
                       di::bind<i59>().to<impl59>())
          BIND_OTHERS6(di::bind<x50>.in(di::unique), di::bind<x51>.in(di::unique), di::bind<x52>.in(di::unique),
                       di::bind<x53>.in(di::unique), di::bind<x54>.in(di::unique), di::bind<x55>.in(di::unique),
                       di::bind<x56>.in(di::unique), di::bind<x57>.in(di::unique), di::bind<x58>.in(di::unique),
                       di::bind<x59>.in(di::unique), di::bind<y50>.in(di::unique), di::bind<y51>.in(di::unique),
                       di::bind<y52>.in(di::unique), di::bind<y53>.in(di::unique), di::bind<y54>.in(di::unique),
                       di::bind<y55>.in(di::unique), di::bind<y56>.in(di::unique), di::bind<y57>.in(di::unique),
                       di::bind<y58>.in(di::unique), di::bind<y59>.in(di::unique))));
};
#endif

#if defined(MODULE7)
EXPOSED_OR_AUTO(di::injector<c6>, auto) module7() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES7(di::bind<i60>().to<impl60>(), di::bind<i61>().to<impl61>(), di::bind<i62>().to<impl62>(),
                       di::bind<i63>().to<impl63>(), di::bind<i64>().to<impl64>(), di::bind<i65>().to<impl65>(),
                       di::bind<i66>().to<impl66>(), di::bind<i67>().to<impl67>(), di::bind<i68>().to<impl68>(),
                       di::bind<i69>().to<impl69>())
          BIND_OTHERS7(di::bind<x60>.in(di::unique), di::bind<x61>.in(di::unique), di::bind<x62>.in(di::unique),
                       di::bind<x63>.in(di::unique), di::bind<x64>.in(di::unique), di::bind<x65>.in(di::unique),
                       di::bind<x66>.in(di::unique), di::bind<x67>.in(di::unique), di::bind<x68>.in(di::unique),
                       di::bind<x69>.in(di::unique), di::bind<y60>.in(di::unique), di::bind<y61>.in(di::unique),
                       di::bind<y62>.in(di::unique), di::bind<y63>.in(di::unique), di::bind<y64>.in(di::unique),
                       di::bind<y65>.in(di::unique), di::bind<y66>.in(di::unique), di::bind<y67>.in(di::unique),
                       di::bind<y68>.in(di::unique), di::bind<y69>.in(di::unique))));
};
#endif

#if defined(MODULE8)
EXPOSED_OR_AUTO(di::injector<c7>, auto) module8() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES8(di::bind<i70>().to<impl70>(), di::bind<i71>().to<impl71>(), di::bind<i72>().to<impl72>(),
                       di::bind<i73>().to<impl73>(), di::bind<i74>().to<impl74>(), di::bind<i75>().to<impl75>(),
                       di::bind<i76>().to<impl76>(), di::bind<i77>().to<impl77>(), di::bind<i78>().to<impl78>(),
                       di::bind<i79>().to<impl79>())
          BIND_OTHERS8(di::bind<x70>.in(di::unique), di::bind<x71>.in(di::unique), di::bind<x72>.in(di::unique),
                       di::bind<x73>.in(di::unique), di::bind<x74>.in(di::unique), di::bind<x75>.in(di::unique),
                       di::bind<x76>.in(di::unique), di::bind<x77>.in(di::unique), di::bind<x78>.in(di::unique),
                       di::bind<x79>.in(di::unique), di::bind<y70>.in(di::unique), di::bind<y71>.in(di::unique),
                       di::bind<y72>.in(di::unique), di::bind<y73>.in(di::unique), di::bind<y74>.in(di::unique),
                       di::bind<y75>.in(di::unique), di::bind<y76>.in(di::unique), di::bind<y77>.in(di::unique),
                       di::bind<y78>.in(di::unique), di::bind<y79>.in(di::unique))));
};
#endif

#if defined(MODULE9)
EXPOSED_OR_AUTO(di::injector<c8>, auto) module9() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES9(di::bind<i80>().to<impl80>(), di::bind<i81>().to<impl81>(), di::bind<i82>().to<impl82>(),
                       di::bind<i83>().to<impl83>(), di::bind<i84>().to<impl84>(), di::bind<i85>().to<impl85>(),
                       di::bind<i86>().to<impl86>(), di::bind<i87>().to<impl87>(), di::bind<i88>().to<impl88>(),
                       di::bind<i89>().to<impl89>())
          BIND_OTHERS9(di::bind<x80>.in(di::unique), di::bind<x81>.in(di::unique), di::bind<x82>.in(di::unique),
                       di::bind<x83>.in(di::unique), di::bind<x84>.in(di::unique), di::bind<x85>.in(di::unique),
                       di::bind<x86>.in(di::unique), di::bind<x87>.in(di::unique), di::bind<x88>.in(di::unique),
                       di::bind<x89>.in(di::unique), di::bind<y80>.in(di::unique), di::bind<y81>.in(di::unique),
                       di::bind<y82>.in(di::unique), di::bind<y83>.in(di::unique), di::bind<y84>.in(di::unique),
                       di::bind<y85>.in(di::unique), di::bind<y86>.in(di::unique), di::bind<y87>.in(di::unique),
                       di::bind<y88>.in(di::unique), di::bind<y89>.in(di::unique))));
};
#endif

#if defined(MODULE10)
EXPOSED_OR_AUTO(di::injector<c9>, auto) module10() noexcept {
  RETURN(di::make_injector(
      BIND_INTERFACES10(di::bind<i90>().to<impl90>(), di::bind<i91>().to<impl91>(), di::bind<i92>().to<impl92>(),
                        di::bind<i93>().to<impl93>(), di::bind<i94>().to<impl94>(), di::bind<i95>().to<impl95>(),
                        di::bind<i96>().to<impl96>(), di::bind<i97>().to<impl97>(), di::bind<i98>().to<impl98>(),
                        di::bind<i99>().to<impl99>())
          BIND_OTHERS10(di::bind<x90>.in(di::unique), di::bind<x91>.in(di::unique), di::bind<x92>.in(di::unique),
                        di::bind<x93>.in(di::unique), di::bind<x94>.in(di::unique), di::bind<x95>.in(di::unique),
                        di::bind<x96>.in(di::unique), di::bind<x97>.in(di::unique), di::bind<x98>.in(di::unique),
                        di::bind<x99>.in(di::unique), di::bind<y90>.in(di::unique), di::bind<y91>.in(di::unique),
                        di::bind<y92>.in(di::unique), di::bind<y93>.in(di::unique), di::bind<y94>.in(di::unique),
                        di::bind<y95>.in(di::unique), di::bind<y96>.in(di::unique), di::bind<y97>.in(di::unique),
                        di::bind<y98>.in(di::unique), di::bind<y99>.in(di::unique))));
};
#endif

int main() {
  auto injector = di::make_injector(
#if defined(MODULE1)
      module1()
#endif

#if defined(MODULE2)
          ,
      module2()
#endif

#if defined(MODULE3)
          ,
      module3()
#endif

#if defined(MODULE4)
          ,
      module4()
#endif

#if defined(MODULE5)
          ,
      module5()
#endif

#if defined(MODULE6)
          ,
      module6()
#endif

#if defined(MODULE7)
          ,
      module7()
#endif

#if defined(MODULE8)
          ,
      module8()
#endif

#if defined(MODULE9)
          ,
      module9()
#endif

#if defined(MODULE10)
          ,
      module10()
#endif
          );

  injector.create<COMPLEX>();
}
