//
// 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 <di/registry.hpp>
#include <di/injector.hpp>
#include <di/constructor.hpp>

// clang-format off
struct X00 { DI_CONSTRUCTOR(X00, ()) { } };
struct X01 { DI_CONSTRUCTOR(X01, (X00)) { } };
struct X02 { DI_CONSTRUCTOR(X02, (X00, X01)) { } };
struct X03 { DI_CONSTRUCTOR(X03, (X00, X01, X02)) { } };
struct X04 { DI_CONSTRUCTOR(X04, (X00, X01, X02, X03)) { } };
struct X05 { DI_CONSTRUCTOR(X05, (X00, X01, X02, X03, X04)) { } };
struct X06 { DI_CONSTRUCTOR(X06, (X00, X01, X02, X03, X04, X05)) { } };
struct X07 { DI_CONSTRUCTOR(X07, (X00, X01, X02, X03, X04, X05, X06)) { } };
struct X08 { DI_CONSTRUCTOR(X08, (X00, X01, X02, X03, X04, X05, X06, X07)) { } };
struct X09 { DI_CONSTRUCTOR(X09, (X00, X01, X02, X03, X04, X05, X06, X07, X08)) { } };
struct X10 { DI_CONSTRUCTOR(X10, (X00, X01, X02, X03, X04, X05, X06, X07, X08, X09)) { } };
struct X11 { DI_CONSTRUCTOR(X11, (X01, X02, X03, X04, X05, X06, X07, X08, X09, X10)) { } };
struct X12 { DI_CONSTRUCTOR(X12, (X02, X03, X04, X05, X06, X07, X08, X09, X10, X11)) { } };
struct X13 { DI_CONSTRUCTOR(X13, (X03, X04, X05, X06, X07, X08, X09, X10, X11, X12)) { } };
struct X14 { DI_CONSTRUCTOR(X14, (X04, X05, X06, X07, X08, X09, X10, X11, X12, X13)) { } };
struct X15 { DI_CONSTRUCTOR(X15, (X05, X06, X07, X08, X09, X10, X11, X12, X13, X14)) { } };
struct X16 { DI_CONSTRUCTOR(X16, (X06, X07, X08, X09, X10, X11, X12, X13, X14, X15)) { } };
struct X17 { DI_CONSTRUCTOR(X17, (X07, X08, X09, X10, X11, X12, X13, X14, X15, X16)) { } };
struct X18 { DI_CONSTRUCTOR(X18, (X08, X09, X10, X11, X12, X13, X14, X15, X16, X17)) { } };
struct X19 { DI_CONSTRUCTOR(X19, (X09, X10, X11, X12, X13, X14, X15, X16, X17, X18)) { } };
struct X20 { DI_CONSTRUCTOR(X20, (X10, X11, X12, X13, X14, X15, X16, X17, X18, X19)) { } };
struct X21 { DI_CONSTRUCTOR(X21, (X11, X12, X13, X14, X15, X16, X17, X18, X19, X20)) { } };
struct X22 { DI_CONSTRUCTOR(X22, (X12, X13, X14, X15, X16, X17, X18, X19, X20, X21)) { } };
struct X23 { DI_CONSTRUCTOR(X23, (X13, X14, X15, X16, X17, X18, X19, X20, X21, X22)) { } };
struct X24 { DI_CONSTRUCTOR(X24, (X14, X15, X16, X17, X18, X19, X20, X21, X22, X23)) { } };
struct X25 { DI_CONSTRUCTOR(X25, (X15, X16, X17, X18, X19, X20, X21, X22, X23, X24)) { } };
struct X26 { DI_CONSTRUCTOR(X26, (X16, X17, X18, X19, X20, X21, X22, X23, X24, X25)) { } };
struct X27 { DI_CONSTRUCTOR(X27, (X17, X18, X19, X20, X21, X22, X23, X24, X25, X26)) { } };
struct X28 { DI_CONSTRUCTOR(X28, (X18, X19, X20, X21, X22, X23, X24, X25, X26, X27)) { } };
struct X29 { DI_CONSTRUCTOR(X29, (X19, X20, X21, X22, X23, X24, X25, X26, X27, X28)) { } };
struct X30 { DI_CONSTRUCTOR(X30, (X20, X21, X22, X23, X24, X25, X26, X27, X28, X29)) { } };
struct X31 { DI_CONSTRUCTOR(X31, (X21, X22, X23, X24, X25, X26, X27, X28, X29, X30)) { } };
struct X32 { DI_CONSTRUCTOR(X32, (X22, X23, X24, X25, X26, X27, X28, X29, X30, X31)) { } };
struct X33 { DI_CONSTRUCTOR(X33, (X23, X24, X25, X26, X27, X28, X29, X30, X31, X32)) { } };
struct X34 { DI_CONSTRUCTOR(X34, (X24, X25, X26, X27, X28, X29, X30, X31, X32, X33)) { } };
struct X35 { DI_CONSTRUCTOR(X35, (X25, X26, X27, X28, X29, X30, X31, X32, X33, X34)) { } };
struct X36 { DI_CONSTRUCTOR(X36, (X26, X27, X28, X29, X30, X31, X32, X33, X34, X35)) { } };
struct X37 { DI_CONSTRUCTOR(X37, (X27, X28, X29, X30, X31, X32, X33, X34, X35, X36)) { } };
struct X38 { DI_CONSTRUCTOR(X38, (X28, X29, X30, X31, X32, X33, X34, X35, X36, X37)) { } };
struct X39 { DI_CONSTRUCTOR(X39, (X29, X30, X31, X32, X33, X34, X35, X36, X37, X38)) { } };
struct X40 { DI_CONSTRUCTOR(X40, (X30, X31, X32, X33, X34, X35, X36, X37, X38, X39)) { } };
struct X41 { DI_CONSTRUCTOR(X41, (X31, X32, X33, X34, X35, X36, X37, X38, X39, X40)) { } };
struct X42 { DI_CONSTRUCTOR(X42, (X32, X33, X34, X35, X36, X37, X38, X39, X40, X41)) { } };
struct X43 { DI_CONSTRUCTOR(X43, (X33, X34, X35, X36, X37, X38, X39, X40, X41, X42)) { } };
struct X44 { DI_CONSTRUCTOR(X44, (X34, X35, X36, X37, X38, X39, X40, X41, X42, X43)) { } };
struct X45 { DI_CONSTRUCTOR(X45, (X35, X36, X37, X38, X39, X40, X41, X42, X43, X44)) { } };
struct X46 { DI_CONSTRUCTOR(X46, (X36, X37, X38, X39, X40, X41, X42, X43, X44, X45)) { } };
struct X47 { DI_CONSTRUCTOR(X47, (X37, X38, X39, X40, X41, X42, X43, X44, X45, X46)) { } };
struct X48 { DI_CONSTRUCTOR(X48, (X38, X39, X40, X41, X42, X43, X44, X45, X46, X47)) { } };
struct X49 { DI_CONSTRUCTOR(X49, (X39, X40, X41, X42, X43, X44, X45, X46, X47, X48)) { } };
struct X50 { DI_CONSTRUCTOR(X50, (X40, X41, X42, X43, X44, X45, X46, X47, X48, X49)) { } };
struct X51 { DI_CONSTRUCTOR(X51, (X41, X42, X43, X44, X45, X46, X47, X48, X49, X50)) { } };
struct X52 { DI_CONSTRUCTOR(X52, (X42, X43, X44, X45, X46, X47, X48, X49, X50, X51)) { } };
struct X53 { DI_CONSTRUCTOR(X53, (X43, X44, X45, X46, X47, X48, X49, X50, X51, X52)) { } };
struct X54 { DI_CONSTRUCTOR(X54, (X44, X45, X46, X47, X48, X49, X50, X51, X52, X53)) { } };
struct X55 { DI_CONSTRUCTOR(X55, (X45, X46, X47, X48, X49, X50, X51, X52, X53, X54)) { } };
struct X56 { DI_CONSTRUCTOR(X56, (X46, X47, X48, X49, X50, X51, X52, X53, X54, X55)) { } };
struct X57 { DI_CONSTRUCTOR(X57, (X47, X48, X49, X50, X51, X52, X53, X54, X55, X56)) { } };
struct X58 { DI_CONSTRUCTOR(X58, (X48, X49, X50, X51, X52, X53, X54, X55, X56, X57)) { } };
struct X59 { DI_CONSTRUCTOR(X59, (X49, X50, X51, X52, X53, X54, X55, X56, X57, X58)) { } };
struct X60 { DI_CONSTRUCTOR(X60, (X50, X51, X52, X53, X54, X55, X56, X57, X58, X59)) { } };
struct X61 { DI_CONSTRUCTOR(X61, (X51, X52, X53, X54, X55, X56, X57, X58, X59, X60)) { } };
struct X62 { DI_CONSTRUCTOR(X62, (X52, X53, X54, X55, X56, X57, X58, X59, X60, X61)) { } };
struct X63 { DI_CONSTRUCTOR(X63, (X53, X54, X55, X56, X57, X58, X59, X60, X61, X62)) { } };
struct X64 { DI_CONSTRUCTOR(X64, (X54, X55, X56, X57, X58, X59, X60, X61, X62, X63)) { } };
struct X65 { DI_CONSTRUCTOR(X65, (X55, X56, X57, X58, X59, X60, X61, X62, X63, X64)) { } };
struct X66 { DI_CONSTRUCTOR(X66, (X56, X57, X58, X59, X60, X61, X62, X63, X64, X65)) { } };
struct X67 { DI_CONSTRUCTOR(X67, (X57, X58, X59, X60, X61, X62, X63, X64, X65, X66)) { } };
struct X68 { DI_CONSTRUCTOR(X68, (X58, X59, X60, X61, X62, X63, X64, X65, X66, X67)) { } };
struct X69 { DI_CONSTRUCTOR(X69, (X59, X60, X61, X62, X63, X64, X65, X66, X67, X68)) { } };
struct X70 { DI_CONSTRUCTOR(X70, (X60, X61, X62, X63, X64, X65, X66, X67, X68, X69)) { } };
struct X71 { DI_CONSTRUCTOR(X71, (X61, X62, X63, X64, X65, X66, X67, X68, X69, X70)) { } };
struct X72 { DI_CONSTRUCTOR(X72, (X62, X63, X64, X65, X66, X67, X68, X69, X70, X71)) { } };
struct X73 { DI_CONSTRUCTOR(X73, (X63, X64, X65, X66, X67, X68, X69, X70, X71, X72)) { } };
struct X74 { DI_CONSTRUCTOR(X74, (X64, X65, X66, X67, X68, X69, X70, X71, X72, X73)) { } };
struct X75 { DI_CONSTRUCTOR(X75, (X65, X66, X67, X68, X69, X70, X71, X72, X73, X74)) { } };
struct X76 { DI_CONSTRUCTOR(X76, (X66, X67, X68, X69, X70, X71, X72, X73, X74, X75)) { } };
struct X77 { DI_CONSTRUCTOR(X77, (X67, X68, X69, X70, X71, X72, X73, X74, X75, X76)) { } };
struct X78 { DI_CONSTRUCTOR(X78, (X68, X69, X70, X71, X72, X73, X74, X75, X76, X77)) { } };
struct X79 { DI_CONSTRUCTOR(X79, (X69, X70, X71, X72, X73, X74, X75, X76, X77, X78)) { } };
struct X80 { DI_CONSTRUCTOR(X80, (X70, X71, X72, X73, X74, X75, X76, X77, X78, X79)) { } };
struct X81 { DI_CONSTRUCTOR(X81, (X71, X72, X73, X74, X75, X76, X77, X78, X79, X80)) { } };
struct X82 { DI_CONSTRUCTOR(X82, (X72, X73, X74, X75, X76, X77, X78, X79, X80, X81)) { } };
struct X83 { DI_CONSTRUCTOR(X83, (X73, X74, X75, X76, X77, X78, X79, X80, X81, X82)) { } };
struct X84 { DI_CONSTRUCTOR(X84, (X74, X75, X76, X77, X78, X79, X80, X81, X82, X83)) { } };
struct X85 { DI_CONSTRUCTOR(X85, (X75, X76, X77, X78, X79, X80, X81, X82, X83, X84)) { } };
struct X86 { DI_CONSTRUCTOR(X86, (X76, X77, X78, X79, X80, X81, X82, X83, X84, X85)) { } };
struct X87 { DI_CONSTRUCTOR(X87, (X77, X78, X79, X80, X81, X82, X83, X84, X85, X86)) { } };
struct X88 { DI_CONSTRUCTOR(X88, (X78, X79, X80, X81, X82, X83, X84, X85, X86, X87)) { } };
struct X89 { DI_CONSTRUCTOR(X89, (X79, X80, X81, X82, X83, X84, X85, X86, X87, X88)) { } };
struct X90 { DI_CONSTRUCTOR(X90, (X80, X81, X82, X83, X84, X85, X86, X87, X88, X89)) { } };
struct X91 { DI_CONSTRUCTOR(X91, (X81, X82, X83, X84, X85, X86, X87, X88, X89, X90)) { } };
struct X92 { DI_CONSTRUCTOR(X92, (X82, X83, X84, X85, X86, X87, X88, X89, X90, X91)) { } };
struct X93 { DI_CONSTRUCTOR(X93, (X83, X84, X85, X86, X87, X88, X89, X90, X91, X92)) { } };
struct X94 { DI_CONSTRUCTOR(X94, (X84, X85, X86, X87, X88, X89, X90, X91, X92, X93)) { } };
struct X95 { DI_CONSTRUCTOR(X95, (X85, X86, X87, X88, X89, X90, X91, X92, X93, X94)) { } };
struct X96 { DI_CONSTRUCTOR(X96, (X86, X87, X88, X89, X90, X91, X92, X93, X94, X95)) { } };
struct X97 { DI_CONSTRUCTOR(X97, (X87, X88, X89, X90, X91, X92, X93, X94, X95, X96)) { } };
struct X98 { DI_CONSTRUCTOR(X98, (X88, X89, X90, X91, X92, X93, X94, X95, X96, X97)) { } };
struct X99 { DI_CONSTRUCTOR(X99, (X89, X90, X91, X92, X93, X94, X95, X96, X97, X98)) { } };
struct I00 { virtual ~I00() noexcept = default; virtual void dummy() = 0; }; struct Impl00 : I00 { DI_CONSTRUCTOR(Impl00, (X00, X01, X02, X03, X04, X05, X06, X07, X08, X09)) { } void dummy() override { } };
struct I01 { virtual ~I01() noexcept = default; virtual void dummy() = 0; }; struct Impl01 : I01 { DI_CONSTRUCTOR(Impl01, (X01, X02, X03, X04, X05, X06, X07, X08, X09, X10)) { } void dummy() override { } };
struct I02 { virtual ~I02() noexcept = default; virtual void dummy() = 0; }; struct Impl02 : I02 { DI_CONSTRUCTOR(Impl02, (X02, X03, X04, X05, X06, X07, X08, X09, X10, X11)) { } void dummy() override { } };
struct I03 { virtual ~I03() noexcept = default; virtual void dummy() = 0; }; struct Impl03 : I03 { DI_CONSTRUCTOR(Impl03, (X03, X04, X05, X06, X07, X08, X09, X10, X11, X12)) { } void dummy() override { } };
struct I04 { virtual ~I04() noexcept = default; virtual void dummy() = 0; }; struct Impl04 : I04 { DI_CONSTRUCTOR(Impl04, (X04, X05, X06, X07, X08, X09, X10, X11, X12, X13)) { } void dummy() override { } };
struct I05 { virtual ~I05() noexcept = default; virtual void dummy() = 0; }; struct Impl05 : I05 { DI_CONSTRUCTOR(Impl05, (X05, X06, X07, X08, X09, X10, X11, X12, X13, X14)) { } void dummy() override { } };
struct I06 { virtual ~I06() noexcept = default; virtual void dummy() = 0; }; struct Impl06 : I06 { DI_CONSTRUCTOR(Impl06, (X06, X07, X08, X09, X10, X11, X12, X13, X14, X15)) { } void dummy() override { } };
struct I07 { virtual ~I07() noexcept = default; virtual void dummy() = 0; }; struct Impl07 : I07 { DI_CONSTRUCTOR(Impl07, (X07, X08, X09, X10, X11, X12, X13, X14, X15, X16)) { } void dummy() override { } };
struct I08 { virtual ~I08() noexcept = default; virtual void dummy() = 0; }; struct Impl08 : I08 { DI_CONSTRUCTOR(Impl08, (X08, X09, X10, X11, X12, X13, X14, X15, X16, X17)) { } void dummy() override { } };
struct I09 { virtual ~I09() noexcept = default; virtual void dummy() = 0; }; struct Impl09 : I09 { DI_CONSTRUCTOR(Impl09, (X09, X10, X11, X12, X13, X14, X15, X16, X17, X18)) { } void dummy() override { } };
struct I10 { virtual ~I10() noexcept = default; virtual void dummy() = 0; }; struct Impl10 : I10 { DI_CONSTRUCTOR(Impl10, (X10, X11, X12, X13, X14, X15, X16, X17, X18, X19)) { } void dummy() override { } };
struct I11 { virtual ~I11() noexcept = default; virtual void dummy() = 0; }; struct Impl11 : I11 { DI_CONSTRUCTOR(Impl11, (X11, X12, X13, X14, X15, X16, X17, X18, X19, X20)) { } void dummy() override { } };
struct I12 { virtual ~I12() noexcept = default; virtual void dummy() = 0; }; struct Impl12 : I12 { DI_CONSTRUCTOR(Impl12, (X12, X13, X14, X15, X16, X17, X18, X19, X20, X21)) { } void dummy() override { } };
struct I13 { virtual ~I13() noexcept = default; virtual void dummy() = 0; }; struct Impl13 : I13 { DI_CONSTRUCTOR(Impl13, (X13, X14, X15, X16, X17, X18, X19, X20, X21, X22)) { } void dummy() override { } };
struct I14 { virtual ~I14() noexcept = default; virtual void dummy() = 0; }; struct Impl14 : I14 { DI_CONSTRUCTOR(Impl14, (X14, X15, X16, X17, X18, X19, X20, X21, X22, X23)) { } void dummy() override { } };
struct I15 { virtual ~I15() noexcept = default; virtual void dummy() = 0; }; struct Impl15 : I15 { DI_CONSTRUCTOR(Impl15, (X15, X16, X17, X18, X19, X20, X21, X22, X23, X24)) { } void dummy() override { } };
struct I16 { virtual ~I16() noexcept = default; virtual void dummy() = 0; }; struct Impl16 : I16 { DI_CONSTRUCTOR(Impl16, (X16, X17, X18, X19, X20, X21, X22, X23, X24, X25)) { } void dummy() override { } };
struct I17 { virtual ~I17() noexcept = default; virtual void dummy() = 0; }; struct Impl17 : I17 { DI_CONSTRUCTOR(Impl17, (X17, X18, X19, X20, X21, X22, X23, X24, X25, X26)) { } void dummy() override { } };
struct I18 { virtual ~I18() noexcept = default; virtual void dummy() = 0; }; struct Impl18 : I18 { DI_CONSTRUCTOR(Impl18, (X18, X19, X20, X21, X22, X23, X24, X25, X26, X27)) { } void dummy() override { } };
struct I19 { virtual ~I19() noexcept = default; virtual void dummy() = 0; }; struct Impl19 : I19 { DI_CONSTRUCTOR(Impl19, (X19, X20, X21, X22, X23, X24, X25, X26, X27, X28)) { } void dummy() override { } };
struct I20 { virtual ~I20() noexcept = default; virtual void dummy() = 0; }; struct Impl20 : I20 { DI_CONSTRUCTOR(Impl20, (X20, X21, X22, X23, X24, X25, X26, X27, X28, X29)) { } void dummy() override { } };
struct I21 { virtual ~I21() noexcept = default; virtual void dummy() = 0; }; struct Impl21 : I21 { DI_CONSTRUCTOR(Impl21, (X21, X22, X23, X24, X25, X26, X27, X28, X29, X30)) { } void dummy() override { } };
struct I22 { virtual ~I22() noexcept = default; virtual void dummy() = 0; }; struct Impl22 : I22 { DI_CONSTRUCTOR(Impl22, (X22, X23, X24, X25, X26, X27, X28, X29, X30, X31)) { } void dummy() override { } };
struct I23 { virtual ~I23() noexcept = default; virtual void dummy() = 0; }; struct Impl23 : I23 { DI_CONSTRUCTOR(Impl23, (X23, X24, X25, X26, X27, X28, X29, X30, X31, X32)) { } void dummy() override { } };
struct I24 { virtual ~I24() noexcept = default; virtual void dummy() = 0; }; struct Impl24 : I24 { DI_CONSTRUCTOR(Impl24, (X24, X25, X26, X27, X28, X29, X30, X31, X32, X33)) { } void dummy() override { } };
struct I25 { virtual ~I25() noexcept = default; virtual void dummy() = 0; }; struct Impl25 : I25 { DI_CONSTRUCTOR(Impl25, (X25, X26, X27, X28, X29, X30, X31, X32, X33, X34)) { } void dummy() override { } };
struct I26 { virtual ~I26() noexcept = default; virtual void dummy() = 0; }; struct Impl26 : I26 { DI_CONSTRUCTOR(Impl26, (X26, X27, X28, X29, X30, X31, X32, X33, X34, X35)) { } void dummy() override { } };
struct I27 { virtual ~I27() noexcept = default; virtual void dummy() = 0; }; struct Impl27 : I27 { DI_CONSTRUCTOR(Impl27, (X27, X28, X29, X30, X31, X32, X33, X34, X35, X36)) { } void dummy() override { } };
struct I28 { virtual ~I28() noexcept = default; virtual void dummy() = 0; }; struct Impl28 : I28 { DI_CONSTRUCTOR(Impl28, (X28, X29, X30, X31, X32, X33, X34, X35, X36, X37)) { } void dummy() override { } };
struct I29 { virtual ~I29() noexcept = default; virtual void dummy() = 0; }; struct Impl29 : I29 { DI_CONSTRUCTOR(Impl29, (X29, X30, X31, X32, X33, X34, X35, X36, X37, X38)) { } void dummy() override { } };
struct I30 { virtual ~I30() noexcept = default; virtual void dummy() = 0; }; struct Impl30 : I30 { DI_CONSTRUCTOR(Impl30, (X30, X31, X32, X33, X34, X35, X36, X37, X38, X39)) { } void dummy() override { } };
struct I31 { virtual ~I31() noexcept = default; virtual void dummy() = 0; }; struct Impl31 : I31 { DI_CONSTRUCTOR(Impl31, (X31, X32, X33, X34, X35, X36, X37, X38, X39, X40)) { } void dummy() override { } };
struct I32 { virtual ~I32() noexcept = default; virtual void dummy() = 0; }; struct Impl32 : I32 { DI_CONSTRUCTOR(Impl32, (X32, X33, X34, X35, X36, X37, X38, X39, X40, X41)) { } void dummy() override { } };
struct I33 { virtual ~I33() noexcept = default; virtual void dummy() = 0; }; struct Impl33 : I33 { DI_CONSTRUCTOR(Impl33, (X33, X34, X35, X36, X37, X38, X39, X40, X41, X42)) { } void dummy() override { } };
struct I34 { virtual ~I34() noexcept = default; virtual void dummy() = 0; }; struct Impl34 : I34 { DI_CONSTRUCTOR(Impl34, (X34, X35, X36, X37, X38, X39, X40, X41, X42, X43)) { } void dummy() override { } };
struct I35 { virtual ~I35() noexcept = default; virtual void dummy() = 0; }; struct Impl35 : I35 { DI_CONSTRUCTOR(Impl35, (X35, X36, X37, X38, X39, X40, X41, X42, X43, X44)) { } void dummy() override { } };
struct I36 { virtual ~I36() noexcept = default; virtual void dummy() = 0; }; struct Impl36 : I36 { DI_CONSTRUCTOR(Impl36, (X36, X37, X38, X39, X40, X41, X42, X43, X44, X45)) { } void dummy() override { } };
struct I37 { virtual ~I37() noexcept = default; virtual void dummy() = 0; }; struct Impl37 : I37 { DI_CONSTRUCTOR(Impl37, (X37, X38, X39, X40, X41, X42, X43, X44, X45, X46)) { } void dummy() override { } };
struct I38 { virtual ~I38() noexcept = default; virtual void dummy() = 0; }; struct Impl38 : I38 { DI_CONSTRUCTOR(Impl38, (X38, X39, X40, X41, X42, X43, X44, X45, X46, X47)) { } void dummy() override { } };
struct I39 { virtual ~I39() noexcept = default; virtual void dummy() = 0; }; struct Impl39 : I39 { DI_CONSTRUCTOR(Impl39, (X39, X40, X41, X42, X43, X44, X45, X46, X47, X48)) { } void dummy() override { } };
struct I40 { virtual ~I40() noexcept = default; virtual void dummy() = 0; }; struct Impl40 : I40 { DI_CONSTRUCTOR(Impl40, (X40, X41, X42, X43, X44, X45, X46, X47, X48, X49)) { } void dummy() override { } };
struct I41 { virtual ~I41() noexcept = default; virtual void dummy() = 0; }; struct Impl41 : I41 { DI_CONSTRUCTOR(Impl41, (X41, X42, X43, X44, X45, X46, X47, X48, X49, X50)) { } void dummy() override { } };
struct I42 { virtual ~I42() noexcept = default; virtual void dummy() = 0; }; struct Impl42 : I42 { DI_CONSTRUCTOR(Impl42, (X42, X43, X44, X45, X46, X47, X48, X49, X50, X51)) { } void dummy() override { } };
struct I43 { virtual ~I43() noexcept = default; virtual void dummy() = 0; }; struct Impl43 : I43 { DI_CONSTRUCTOR(Impl43, (X43, X44, X45, X46, X47, X48, X49, X50, X51, X52)) { } void dummy() override { } };
struct I44 { virtual ~I44() noexcept = default; virtual void dummy() = 0; }; struct Impl44 : I44 { DI_CONSTRUCTOR(Impl44, (X44, X45, X46, X47, X48, X49, X50, X51, X52, X53)) { } void dummy() override { } };
struct I45 { virtual ~I45() noexcept = default; virtual void dummy() = 0; }; struct Impl45 : I45 { DI_CONSTRUCTOR(Impl45, (X45, X46, X47, X48, X49, X50, X51, X52, X53, X54)) { } void dummy() override { } };
struct I46 { virtual ~I46() noexcept = default; virtual void dummy() = 0; }; struct Impl46 : I46 { DI_CONSTRUCTOR(Impl46, (X46, X47, X48, X49, X50, X51, X52, X53, X54, X55)) { } void dummy() override { } };
struct I47 { virtual ~I47() noexcept = default; virtual void dummy() = 0; }; struct Impl47 : I47 { DI_CONSTRUCTOR(Impl47, (X47, X48, X49, X50, X51, X52, X53, X54, X55, X56)) { } void dummy() override { } };
struct I48 { virtual ~I48() noexcept = default; virtual void dummy() = 0; }; struct Impl48 : I48 { DI_CONSTRUCTOR(Impl48, (X48, X49, X50, X51, X52, X53, X54, X55, X56, X57)) { } void dummy() override { } };
struct I49 { virtual ~I49() noexcept = default; virtual void dummy() = 0; }; struct Impl49 : I49 { DI_CONSTRUCTOR(Impl49, (X49, X50, X51, X52, X53, X54, X55, X56, X57, X58)) { } void dummy() override { } };
struct I50 { virtual ~I50() noexcept = default; virtual void dummy() = 0; }; struct Impl50 : I50 { DI_CONSTRUCTOR(Impl50, (X50, X51, X52, X53, X54, X55, X56, X57, X58, X59)) { } void dummy() override { } };
struct I51 { virtual ~I51() noexcept = default; virtual void dummy() = 0; }; struct Impl51 : I51 { DI_CONSTRUCTOR(Impl51, (X51, X52, X53, X54, X55, X56, X57, X58, X59, X60)) { } void dummy() override { } };
struct I52 { virtual ~I52() noexcept = default; virtual void dummy() = 0; }; struct Impl52 : I52 { DI_CONSTRUCTOR(Impl52, (X52, X53, X54, X55, X56, X57, X58, X59, X60, X61)) { } void dummy() override { } };
struct I53 { virtual ~I53() noexcept = default; virtual void dummy() = 0; }; struct Impl53 : I53 { DI_CONSTRUCTOR(Impl53, (X53, X54, X55, X56, X57, X58, X59, X60, X61, X62)) { } void dummy() override { } };
struct I54 { virtual ~I54() noexcept = default; virtual void dummy() = 0; }; struct Impl54 : I54 { DI_CONSTRUCTOR(Impl54, (X54, X55, X56, X57, X58, X59, X60, X61, X62, X63)) { } void dummy() override { } };
struct I55 { virtual ~I55() noexcept = default; virtual void dummy() = 0; }; struct Impl55 : I55 { DI_CONSTRUCTOR(Impl55, (X55, X56, X57, X58, X59, X60, X61, X62, X63, X64)) { } void dummy() override { } };
struct I56 { virtual ~I56() noexcept = default; virtual void dummy() = 0; }; struct Impl56 : I56 { DI_CONSTRUCTOR(Impl56, (X56, X57, X58, X59, X60, X61, X62, X63, X64, X65)) { } void dummy() override { } };
struct I57 { virtual ~I57() noexcept = default; virtual void dummy() = 0; }; struct Impl57 : I57 { DI_CONSTRUCTOR(Impl57, (X57, X58, X59, X60, X61, X62, X63, X64, X65, X66)) { } void dummy() override { } };
struct I58 { virtual ~I58() noexcept = default; virtual void dummy() = 0; }; struct Impl58 : I58 { DI_CONSTRUCTOR(Impl58, (X58, X59, X60, X61, X62, X63, X64, X65, X66, X67)) { } void dummy() override { } };
struct I59 { virtual ~I59() noexcept = default; virtual void dummy() = 0; }; struct Impl59 : I59 { DI_CONSTRUCTOR(Impl59, (X59, X60, X61, X62, X63, X64, X65, X66, X67, X68)) { } void dummy() override { } };
struct I60 { virtual ~I60() noexcept = default; virtual void dummy() = 0; }; struct Impl60 : I60 { DI_CONSTRUCTOR(Impl60, (X60, X61, X62, X63, X64, X65, X66, X67, X68, X69)) { } void dummy() override { } };
struct I61 { virtual ~I61() noexcept = default; virtual void dummy() = 0; }; struct Impl61 : I61 { DI_CONSTRUCTOR(Impl61, (X61, X62, X63, X64, X65, X66, X67, X68, X69, X70)) { } void dummy() override { } };
struct I62 { virtual ~I62() noexcept = default; virtual void dummy() = 0; }; struct Impl62 : I62 { DI_CONSTRUCTOR(Impl62, (X62, X63, X64, X65, X66, X67, X68, X69, X70, X71)) { } void dummy() override { } };
struct I63 { virtual ~I63() noexcept = default; virtual void dummy() = 0; }; struct Impl63 : I63 { DI_CONSTRUCTOR(Impl63, (X63, X64, X65, X66, X67, X68, X69, X70, X71, X72)) { } void dummy() override { } };
struct I64 { virtual ~I64() noexcept = default; virtual void dummy() = 0; }; struct Impl64 : I64 { DI_CONSTRUCTOR(Impl64, (X64, X65, X66, X67, X68, X69, X70, X71, X72, X73)) { } void dummy() override { } };
struct I65 { virtual ~I65() noexcept = default; virtual void dummy() = 0; }; struct Impl65 : I65 { DI_CONSTRUCTOR(Impl65, (X65, X66, X67, X68, X69, X70, X71, X72, X73, X74)) { } void dummy() override { } };
struct I66 { virtual ~I66() noexcept = default; virtual void dummy() = 0; }; struct Impl66 : I66 { DI_CONSTRUCTOR(Impl66, (X66, X67, X68, X69, X70, X71, X72, X73, X74, X75)) { } void dummy() override { } };
struct I67 { virtual ~I67() noexcept = default; virtual void dummy() = 0; }; struct Impl67 : I67 { DI_CONSTRUCTOR(Impl67, (X67, X68, X69, X70, X71, X72, X73, X74, X75, X76)) { } void dummy() override { } };
struct I68 { virtual ~I68() noexcept = default; virtual void dummy() = 0; }; struct Impl68 : I68 { DI_CONSTRUCTOR(Impl68, (X68, X69, X70, X71, X72, X73, X74, X75, X76, X77)) { } void dummy() override { } };
struct I69 { virtual ~I69() noexcept = default; virtual void dummy() = 0; }; struct Impl69 : I69 { DI_CONSTRUCTOR(Impl69, (X69, X70, X71, X72, X73, X74, X75, X76, X77, X78)) { } void dummy() override { } };
struct I70 { virtual ~I70() noexcept = default; virtual void dummy() = 0; }; struct Impl70 : I70 { DI_CONSTRUCTOR(Impl70, (X70, X71, X72, X73, X74, X75, X76, X77, X78, X79)) { } void dummy() override { } };
struct I71 { virtual ~I71() noexcept = default; virtual void dummy() = 0; }; struct Impl71 : I71 { DI_CONSTRUCTOR(Impl71, (X71, X72, X73, X74, X75, X76, X77, X78, X79, X80)) { } void dummy() override { } };
struct I72 { virtual ~I72() noexcept = default; virtual void dummy() = 0; }; struct Impl72 : I72 { DI_CONSTRUCTOR(Impl72, (X72, X73, X74, X75, X76, X77, X78, X79, X80, X81)) { } void dummy() override { } };
struct I73 { virtual ~I73() noexcept = default; virtual void dummy() = 0; }; struct Impl73 : I73 { DI_CONSTRUCTOR(Impl73, (X73, X74, X75, X76, X77, X78, X79, X80, X81, X82)) { } void dummy() override { } };
struct I74 { virtual ~I74() noexcept = default; virtual void dummy() = 0; }; struct Impl74 : I74 { DI_CONSTRUCTOR(Impl74, (X74, X75, X76, X77, X78, X79, X80, X81, X82, X83)) { } void dummy() override { } };
struct I75 { virtual ~I75() noexcept = default; virtual void dummy() = 0; }; struct Impl75 : I75 { DI_CONSTRUCTOR(Impl75, (X75, X76, X77, X78, X79, X80, X81, X82, X83, X84)) { } void dummy() override { } };
struct I76 { virtual ~I76() noexcept = default; virtual void dummy() = 0; }; struct Impl76 : I76 { DI_CONSTRUCTOR(Impl76, (X76, X77, X78, X79, X80, X81, X82, X83, X84, X85)) { } void dummy() override { } };
struct I77 { virtual ~I77() noexcept = default; virtual void dummy() = 0; }; struct Impl77 : I77 { DI_CONSTRUCTOR(Impl77, (X77, X78, X79, X80, X81, X82, X83, X84, X85, X86)) { } void dummy() override { } };
struct I78 { virtual ~I78() noexcept = default; virtual void dummy() = 0; }; struct Impl78 : I78 { DI_CONSTRUCTOR(Impl78, (X78, X79, X80, X81, X82, X83, X84, X85, X86, X87)) { } void dummy() override { } };
struct I79 { virtual ~I79() noexcept = default; virtual void dummy() = 0; }; struct Impl79 : I79 { DI_CONSTRUCTOR(Impl79, (X79, X80, X81, X82, X83, X84, X85, X86, X87, X88)) { } void dummy() override { } };
struct I80 { virtual ~I80() noexcept = default; virtual void dummy() = 0; }; struct Impl80 : I80 { DI_CONSTRUCTOR(Impl80, (X80, X81, X82, X83, X84, X85, X86, X87, X88, X89)) { } void dummy() override { } };
struct I81 { virtual ~I81() noexcept = default; virtual void dummy() = 0; }; struct Impl81 : I81 { DI_CONSTRUCTOR(Impl81, (X81, X82, X83, X84, X85, X86, X87, X88, X89, X90)) { } void dummy() override { } };
struct I82 { virtual ~I82() noexcept = default; virtual void dummy() = 0; }; struct Impl82 : I82 { DI_CONSTRUCTOR(Impl82, (X82, X83, X84, X85, X86, X87, X88, X89, X90, X91)) { } void dummy() override { } };
struct I83 { virtual ~I83() noexcept = default; virtual void dummy() = 0; }; struct Impl83 : I83 { DI_CONSTRUCTOR(Impl83, (X83, X84, X85, X86, X87, X88, X89, X90, X91, X92)) { } void dummy() override { } };
struct I84 { virtual ~I84() noexcept = default; virtual void dummy() = 0; }; struct Impl84 : I84 { DI_CONSTRUCTOR(Impl84, (X84, X85, X86, X87, X88, X89, X90, X91, X92, X93)) { } void dummy() override { } };
struct I85 { virtual ~I85() noexcept = default; virtual void dummy() = 0; }; struct Impl85 : I85 { DI_CONSTRUCTOR(Impl85, (X85, X86, X87, X88, X89, X90, X91, X92, X93, X94)) { } void dummy() override { } };
struct I86 { virtual ~I86() noexcept = default; virtual void dummy() = 0; }; struct Impl86 : I86 { DI_CONSTRUCTOR(Impl86, (X86, X87, X88, X89, X90, X91, X92, X93, X94, X95)) { } void dummy() override { } };
struct I87 { virtual ~I87() noexcept = default; virtual void dummy() = 0; }; struct Impl87 : I87 { DI_CONSTRUCTOR(Impl87, (X87, X88, X89, X90, X91, X92, X93, X94, X95, X96)) { } void dummy() override { } };
struct I88 { virtual ~I88() noexcept = default; virtual void dummy() = 0; }; struct Impl88 : I88 { DI_CONSTRUCTOR(Impl88, (X88, X89, X90, X91, X92, X93, X94, X95, X96, X97)) { } void dummy() override { } };
struct I89 { virtual ~I89() noexcept = default; virtual void dummy() = 0; }; struct Impl89 : I89 { DI_CONSTRUCTOR(Impl89, (X89, X90, X91, X92, X93, X94, X95, X96, X97, X98)) { } void dummy() override { } };
struct I90 { virtual ~I90() noexcept = default; virtual void dummy() = 0; }; struct Impl90 : I90 { DI_CONSTRUCTOR(Impl90, (X90, X91, X92, X93, X94, X95, X96, X97, X98, X99)) { } void dummy() override { } };
struct I91 { virtual ~I91() noexcept = default; virtual void dummy() = 0; }; struct Impl91 : I91 { DI_CONSTRUCTOR(Impl91, (X91, X92, X93, X94, X95, X96, X97, X98, X99, X00)) { } void dummy() override { } };
struct I92 { virtual ~I92() noexcept = default; virtual void dummy() = 0; }; struct Impl92 : I92 { DI_CONSTRUCTOR(Impl92, (X92, X93, X94, X95, X96, X97, X98, X99, X00, X01)) { } void dummy() override { } };
struct I93 { virtual ~I93() noexcept = default; virtual void dummy() = 0; }; struct Impl93 : I93 { DI_CONSTRUCTOR(Impl93, (X93, X94, X95, X96, X97, X98, X99, X00, X01, X02)) { } void dummy() override { } };
struct I94 { virtual ~I94() noexcept = default; virtual void dummy() = 0; }; struct Impl94 : I94 { DI_CONSTRUCTOR(Impl94, (X94, X95, X96, X97, X98, X99, X00, X01, X02, X03)) { } void dummy() override { } };
struct I95 { virtual ~I95() noexcept = default; virtual void dummy() = 0; }; struct Impl95 : I95 { DI_CONSTRUCTOR(Impl95, (X95, X96, X97, X98, X99, X00, X01, X02, X03, X04)) { } void dummy() override { } };
struct I96 { virtual ~I96() noexcept = default; virtual void dummy() = 0; }; struct Impl96 : I96 { DI_CONSTRUCTOR(Impl96, (X96, X97, X98, X99, X00, X01, X02, X03, X04, X05)) { } void dummy() override { } };
struct I97 { virtual ~I97() noexcept = default; virtual void dummy() = 0; }; struct Impl97 : I97 { DI_CONSTRUCTOR(Impl97, (X97, X98, X99, X00, X01, X02, X03, X04, X05, X06)) { } void dummy() override { } };
struct I98 { virtual ~I98() noexcept = default; virtual void dummy() = 0; }; struct Impl98 : I98 { DI_CONSTRUCTOR(Impl98, (X98, X99, X00, X01, X02, X03, X04, X05, X06, X07)) { } void dummy() override { } };
struct I99 { virtual ~I99() noexcept = default; virtual void dummy() = 0; }; struct Impl99 : I99 { DI_CONSTRUCTOR(Impl99, (X99, X00, X01, X02, X03, X04, X05, X06, X07, X08)) { } void dummy() override { } };
struct C0 { DI_CONSTRUCTOR(C0, (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>)) { } };
struct C1 { DI_CONSTRUCTOR(C1, (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>)) { } };
struct C2 { DI_CONSTRUCTOR(C2, (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>)) { } };
struct C3 { DI_CONSTRUCTOR(C3, (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>)) { } };
struct C4 { DI_CONSTRUCTOR(C4, (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>)) { } };
struct C5 { DI_CONSTRUCTOR(C5, (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>)) { } };
struct C6 { DI_CONSTRUCTOR(C6, (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>)) { } };
struct C7 { DI_CONSTRUCTOR(C7, (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>)) { } };
struct C8 { DI_CONSTRUCTOR(C8, (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>)) { } };
struct C9 { DI_CONSTRUCTOR(C9, (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>)) { } };
struct Complex { DI_CONSTRUCTOR(Complex, (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)) { } };
// clang-format on

void module(di::registry& r) {
  r.add(r.type<I00>().implementation<Impl00>());
  r.add(r.type<I01>().implementation<Impl01>());
  r.add(r.type<I02>().implementation<Impl02>());
  r.add(r.type<I03>().implementation<Impl03>());
  r.add(r.type<I04>().implementation<Impl04>());
  r.add(r.type<I05>().implementation<Impl05>());
  r.add(r.type<I06>().implementation<Impl06>());
  r.add(r.type<I07>().implementation<Impl07>());
  r.add(r.type<I08>().implementation<Impl08>());
  r.add(r.type<I09>().implementation<Impl09>());
  r.add(r.type<I10>().implementation<Impl10>());
  r.add(r.type<I11>().implementation<Impl11>());
  r.add(r.type<I12>().implementation<Impl12>());
  r.add(r.type<I13>().implementation<Impl13>());
  r.add(r.type<I14>().implementation<Impl14>());
  r.add(r.type<I15>().implementation<Impl15>());
  r.add(r.type<I16>().implementation<Impl16>());
  r.add(r.type<I17>().implementation<Impl17>());
  r.add(r.type<I18>().implementation<Impl18>());
  r.add(r.type<I19>().implementation<Impl19>());
  r.add(r.type<I20>().implementation<Impl20>());
  r.add(r.type<I21>().implementation<Impl21>());
  r.add(r.type<I22>().implementation<Impl22>());
  r.add(r.type<I23>().implementation<Impl23>());
  r.add(r.type<I24>().implementation<Impl24>());
  r.add(r.type<I25>().implementation<Impl25>());
  r.add(r.type<I26>().implementation<Impl26>());
  r.add(r.type<I27>().implementation<Impl27>());
  r.add(r.type<I28>().implementation<Impl28>());
  r.add(r.type<I29>().implementation<Impl29>());
  r.add(r.type<I30>().implementation<Impl30>());
  r.add(r.type<I31>().implementation<Impl31>());
  r.add(r.type<I32>().implementation<Impl32>());
  r.add(r.type<I33>().implementation<Impl33>());
  r.add(r.type<I34>().implementation<Impl34>());
  r.add(r.type<I35>().implementation<Impl35>());
  r.add(r.type<I36>().implementation<Impl36>());
  r.add(r.type<I37>().implementation<Impl37>());
  r.add(r.type<I38>().implementation<Impl38>());
  r.add(r.type<I39>().implementation<Impl39>());
  r.add(r.type<I40>().implementation<Impl40>());
  r.add(r.type<I41>().implementation<Impl41>());
  r.add(r.type<I42>().implementation<Impl42>());
  r.add(r.type<I43>().implementation<Impl43>());
  r.add(r.type<I44>().implementation<Impl44>());
  r.add(r.type<I45>().implementation<Impl45>());
  r.add(r.type<I46>().implementation<Impl46>());
  r.add(r.type<I47>().implementation<Impl47>());
  r.add(r.type<I48>().implementation<Impl48>());
  r.add(r.type<I49>().implementation<Impl49>());
  r.add(r.type<I50>().implementation<Impl50>());
  r.add(r.type<I51>().implementation<Impl51>());
  r.add(r.type<I52>().implementation<Impl52>());
  r.add(r.type<I53>().implementation<Impl53>());
  r.add(r.type<I54>().implementation<Impl54>());
  r.add(r.type<I55>().implementation<Impl55>());
  r.add(r.type<I56>().implementation<Impl56>());
  r.add(r.type<I57>().implementation<Impl57>());
  r.add(r.type<I58>().implementation<Impl58>());
  r.add(r.type<I59>().implementation<Impl59>());
  r.add(r.type<I60>().implementation<Impl60>());
  r.add(r.type<I61>().implementation<Impl61>());
  r.add(r.type<I62>().implementation<Impl62>());
  r.add(r.type<I63>().implementation<Impl63>());
  r.add(r.type<I64>().implementation<Impl64>());
  r.add(r.type<I65>().implementation<Impl65>());
  r.add(r.type<I66>().implementation<Impl66>());
  r.add(r.type<I67>().implementation<Impl67>());
  r.add(r.type<I68>().implementation<Impl68>());
  r.add(r.type<I69>().implementation<Impl69>());
  r.add(r.type<I70>().implementation<Impl70>());
  r.add(r.type<I71>().implementation<Impl71>());
  r.add(r.type<I72>().implementation<Impl72>());
  r.add(r.type<I73>().implementation<Impl73>());
  r.add(r.type<I74>().implementation<Impl74>());
  r.add(r.type<I75>().implementation<Impl75>());
  r.add(r.type<I76>().implementation<Impl76>());
  r.add(r.type<I77>().implementation<Impl77>());
  r.add(r.type<I78>().implementation<Impl78>());
  r.add(r.type<I79>().implementation<Impl79>());
  r.add(r.type<I80>().implementation<Impl80>());
  r.add(r.type<I81>().implementation<Impl81>());
  r.add(r.type<I82>().implementation<Impl82>());
  r.add(r.type<I83>().implementation<Impl83>());
  r.add(r.type<I84>().implementation<Impl84>());
  r.add(r.type<I85>().implementation<Impl85>());
  r.add(r.type<I86>().implementation<Impl86>());
  r.add(r.type<I87>().implementation<Impl87>());
  r.add(r.type<I88>().implementation<Impl88>());
  r.add(r.type<I89>().implementation<Impl89>());
  r.add(r.type<I90>().implementation<Impl90>());
  r.add(r.type<I91>().implementation<Impl91>());
  r.add(r.type<I92>().implementation<Impl92>());
  r.add(r.type<I93>().implementation<Impl93>());
  r.add(r.type<I94>().implementation<Impl94>());
  r.add(r.type<I95>().implementation<Impl95>());
  r.add(r.type<I96>().implementation<Impl96>());
  r.add(r.type<I97>().implementation<Impl97>());
  r.add(r.type<I98>().implementation<Impl98>());
  r.add(r.type<I99>().implementation<Impl99>());
}

int main() {
  di::injector injector;
  injector.install(module);
  injector.construct<Complex>();
}
