cpp_mangling_test_linux_64.d

// DO NOT EDIT MANUALLY
// This code is autogenerated.
// Have a look at test/cpp_mangling_tools/README.md for more informations.

import core.stdc.config;

version(linux):
static if(ptrdiff_t.sizeof == 8): // Only for 64 bits systems

struct S {}

extern(C++) {

// // Combination of arguments to test basic types and substitutions.
// void foo_0_() {}
void foo_0_();
static assert(foo_0_.mangleof == "_Z6foo_0_v");

// // Combination of arguments to test basic types and substitutions.
// void foo_1_(bool) {}
void foo_1_(bool);
static assert(foo_1_.mangleof == "_Z6foo_1_b");

// // Combination of arguments to test basic types and substitutions.
// void foo_2_(signed char) {}
void foo_2_(byte);
static assert(foo_2_.mangleof == "_Z6foo_2_a");

// // Combination of arguments to test basic types and substitutions.
// void foo_3_(unsigned char) {}
void foo_3_(ubyte);
static assert(foo_3_.mangleof == "_Z6foo_3_h");

// // Combination of arguments to test basic types and substitutions.
// void foo_4_(char) {}
void foo_4_(char);
static assert(foo_4_.mangleof == "_Z6foo_4_c");

// // Combination of arguments to test basic types and substitutions.
// void foo_5_(wchar_t) {}
void foo_5_(dchar);
static assert(foo_5_.mangleof == "_Z6foo_5_w");

// // Combination of arguments to test basic types and substitutions.
// void foo_6_(short) {}
void foo_6_(short);
static assert(foo_6_.mangleof == "_Z6foo_6_s");

// // Combination of arguments to test basic types and substitutions.
// void foo_7_(unsigned short) {}
void foo_7_(ushort);
static assert(foo_7_.mangleof == "_Z6foo_7_t");

// // Combination of arguments to test basic types and substitutions.
// void foo_8_(int) {}
void foo_8_(int);
static assert(foo_8_.mangleof == "_Z6foo_8_i");

// // Combination of arguments to test basic types and substitutions.
// void foo_9_(unsigned int) {}
void foo_9_(uint);
static assert(foo_9_.mangleof == "_Z6foo_9_j");

// // Combination of arguments to test basic types and substitutions.
// void foo_10_(long) {}
void foo_10_(core.stdc.config.c_long);
static assert(foo_10_.mangleof == "_Z7foo_10_l");

// // Combination of arguments to test basic types and substitutions.
// void foo_11_(unsigned long) {}
void foo_11_(core.stdc.config.c_ulong);
static assert(foo_11_.mangleof == "_Z7foo_11_m");

// // Combination of arguments to test basic types and substitutions.
// void foo_12_(float) {}
void foo_12_(float);
static assert(foo_12_.mangleof == "_Z7foo_12_f");

// // Combination of arguments to test basic types and substitutions.
// void foo_13_(double) {}
void foo_13_(double);
static assert(foo_13_.mangleof == "_Z7foo_13_d");

// // Combination of arguments to test basic types and substitutions.
// void foo_14_(long double) {}
void foo_14_(real);
static assert(foo_14_.mangleof == "_Z7foo_14_e");

// // Combination of arguments to test basic types and substitutions.
// void foo_15_(size_t) {}
void foo_15_(size_t);
static assert(foo_15_.mangleof == "_Z7foo_15_m");

// // Combination of arguments to test basic types and substitutions.
// void foo_16_(ptrdiff_t) {}
void foo_16_(ptrdiff_t);
static assert(foo_16_.mangleof == "_Z7foo_16_l");

// // Combination of arguments to test basic types and substitutions.
// void foo_17_(S) {}
void foo_17_(S);
static assert(foo_17_.mangleof == "_Z7foo_17_1S");

// // Combination of arguments to test basic types and substitutions.
// void foo_18_(int*) {}
void foo_18_(int*);
static assert(foo_18_.mangleof == "_Z7foo_18_Pi");

// // Combination of arguments to test basic types and substitutions.
// void foo_19_(const int*) {}
void foo_19_(const(int)*);
static assert(foo_19_.mangleof == "_Z7foo_19_PKi");

// // Combination of arguments to test basic types and substitutions.
// void foo_20_(const int* const) {}
void foo_20_(const(int*));
static assert(foo_20_.mangleof == "_Z7foo_20_PKi");

// // Combination of arguments to test basic types and substitutions.
// void foo_21_(S*) {}
void foo_21_(S*);
static assert(foo_21_.mangleof == "_Z7foo_21_P1S");

// // Combination of arguments to test basic types and substitutions.
// void foo_22_(const S*) {}
void foo_22_(const(S)*);
static assert(foo_22_.mangleof == "_Z7foo_22_PK1S");

// // Combination of arguments to test basic types and substitutions.
// void foo_23_(const S* const) {}
void foo_23_(const(S*));
static assert(foo_23_.mangleof == "_Z7foo_23_PK1S");

// // Combination of arguments to test basic types and substitutions.
// void foo_24_(int&) {}
void foo_24_(ref int);
static assert(foo_24_.mangleof == "_Z7foo_24_Ri");

// // Combination of arguments to test basic types and substitutions.
// void foo_25_(const int&) {}
void foo_25_(const ref int);
static assert(foo_25_.mangleof == "_Z7foo_25_RKi");

// // Combination of arguments to test basic types and substitutions.
// void foo_26_(S&) {}
void foo_26_(ref S);
static assert(foo_26_.mangleof == "_Z7foo_26_R1S");

// // Combination of arguments to test basic types and substitutions.
// void foo_27_(const S&) {}
void foo_27_(const ref S);
static assert(foo_27_.mangleof == "_Z7foo_27_RK1S");

// // Combination of arguments to test basic types and substitutions.
// void foo_28_(void*(*)()) {}
void foo_28_(void* function());
static assert(foo_28_.mangleof == "_Z7foo_28_PFPvvE");

// // Combination of arguments to test basic types and substitutions.
// void foo_29_(int(*)(int)) {}
void foo_29_(int function(int));
static assert(foo_29_.mangleof == "_Z7foo_29_PFiiE");

// // Combination of arguments to test basic types and substitutions.
// void foo_30_(void*(*)(), void*) {}
void foo_30_(void* function(), void*);
static assert(foo_30_.mangleof == "_Z7foo_30_PFPvvES_");

// // Combination of arguments to test basic types and substitutions.
// void foo_31_(void(*)(void*), void*) {}
void foo_31_(void function(void*), void*);
static assert(foo_31_.mangleof == "_Z7foo_31_PFvPvES_");

// // Combination of arguments to test basic types and substitutions.
// void foo_32_(void*(*)(void**), void*) {}
void foo_32_(void* function(void**), void*);
static assert(foo_32_.mangleof == "_Z7foo_32_PFPvPS_ES_");

// // Combination of arguments to test basic types and substitutions.
// void foo_33_(void*(*)(void**), void**) {}
void foo_33_(void* function(void**), void**);
static assert(foo_33_.mangleof == "_Z7foo_33_PFPvPS_ES0_");

// // Combination of arguments to test basic types and substitutions.
// void foo_34_(void*(*)(void*), void*(*)(void*)) {}
void foo_34_(void* function(void*), void* function(void*));
static assert(foo_34_.mangleof == "_Z7foo_34_PFPvS_ES1_");

// // Combination of arguments for a struct member.
// struct S_35_ {
//     void foo_36_();
// };
// 
// void S_35_::foo_36_() {}
struct S_35_ {
    void foo_36_();
}
static assert(S_35_.foo_36_.mangleof == "_ZN5S_35_7foo_36_Ev");

// // Combination of arguments for a struct member.
// struct S_37_ {
//     void foo_38_(bool);
// };
// 
// void S_37_::foo_38_(bool) {}
struct S_37_ {
    void foo_38_(bool);
}
static assert(S_37_.foo_38_.mangleof == "_ZN5S_37_7foo_38_Eb");

// // Combination of arguments for a struct member.
// struct S_39_ {
//     void foo_40_(signed char);
// };
// 
// void S_39_::foo_40_(signed char) {}
struct S_39_ {
    void foo_40_(byte);
}
static assert(S_39_.foo_40_.mangleof == "_ZN5S_39_7foo_40_Ea");

// // Combination of arguments for a struct member.
// struct S_41_ {
//     void foo_42_(unsigned char);
// };
// 
// void S_41_::foo_42_(unsigned char) {}
struct S_41_ {
    void foo_42_(ubyte);
}
static assert(S_41_.foo_42_.mangleof == "_ZN5S_41_7foo_42_Eh");

// // Combination of arguments for a struct member.
// struct S_43_ {
//     void foo_44_(char);
// };
// 
// void S_43_::foo_44_(char) {}
struct S_43_ {
    void foo_44_(char);
}
static assert(S_43_.foo_44_.mangleof == "_ZN5S_43_7foo_44_Ec");

// // Combination of arguments for a struct member.
// struct S_45_ {
//     void foo_46_(wchar_t);
// };
// 
// void S_45_::foo_46_(wchar_t) {}
struct S_45_ {
    void foo_46_(dchar);
}
static assert(S_45_.foo_46_.mangleof == "_ZN5S_45_7foo_46_Ew");

// // Combination of arguments for a struct member.
// struct S_47_ {
//     void foo_48_(short);
// };
// 
// void S_47_::foo_48_(short) {}
struct S_47_ {
    void foo_48_(short);
}
static assert(S_47_.foo_48_.mangleof == "_ZN5S_47_7foo_48_Es");

// // Combination of arguments for a struct member.
// struct S_49_ {
//     void foo_50_(unsigned short);
// };
// 
// void S_49_::foo_50_(unsigned short) {}
struct S_49_ {
    void foo_50_(ushort);
}
static assert(S_49_.foo_50_.mangleof == "_ZN5S_49_7foo_50_Et");

// // Combination of arguments for a struct member.
// struct S_51_ {
//     void foo_52_(int);
// };
// 
// void S_51_::foo_52_(int) {}
struct S_51_ {
    void foo_52_(int);
}
static assert(S_51_.foo_52_.mangleof == "_ZN5S_51_7foo_52_Ei");

// // Combination of arguments for a struct member.
// struct S_53_ {
//     void foo_54_(unsigned int);
// };
// 
// void S_53_::foo_54_(unsigned int) {}
struct S_53_ {
    void foo_54_(uint);
}
static assert(S_53_.foo_54_.mangleof == "_ZN5S_53_7foo_54_Ej");

// // Combination of arguments for a struct member.
// struct S_55_ {
//     void foo_56_(long);
// };
// 
// void S_55_::foo_56_(long) {}
struct S_55_ {
    void foo_56_(core.stdc.config.c_long);
}
static assert(S_55_.foo_56_.mangleof == "_ZN5S_55_7foo_56_El");

// // Combination of arguments for a struct member.
// struct S_57_ {
//     void foo_58_(unsigned long);
// };
// 
// void S_57_::foo_58_(unsigned long) {}
struct S_57_ {
    void foo_58_(core.stdc.config.c_ulong);
}
static assert(S_57_.foo_58_.mangleof == "_ZN5S_57_7foo_58_Em");

// // Combination of arguments for a struct member.
// struct S_59_ {
//     void foo_60_(float);
// };
// 
// void S_59_::foo_60_(float) {}
struct S_59_ {
    void foo_60_(float);
}
static assert(S_59_.foo_60_.mangleof == "_ZN5S_59_7foo_60_Ef");

// // Combination of arguments for a struct member.
// struct S_61_ {
//     void foo_62_(double);
// };
// 
// void S_61_::foo_62_(double) {}
struct S_61_ {
    void foo_62_(double);
}
static assert(S_61_.foo_62_.mangleof == "_ZN5S_61_7foo_62_Ed");

// // Combination of arguments for a struct member.
// struct S_63_ {
//     void foo_64_(long double);
// };
// 
// void S_63_::foo_64_(long double) {}
struct S_63_ {
    void foo_64_(real);
}
static assert(S_63_.foo_64_.mangleof == "_ZN5S_63_7foo_64_Ee");

// // Combination of arguments for a struct member.
// struct S_65_ {
//     void foo_66_(size_t);
// };
// 
// void S_65_::foo_66_(size_t) {}
struct S_65_ {
    void foo_66_(size_t);
}
static assert(S_65_.foo_66_.mangleof == "_ZN5S_65_7foo_66_Em");

// // Combination of arguments for a struct member.
// struct S_67_ {
//     void foo_68_(ptrdiff_t);
// };
// 
// void S_67_::foo_68_(ptrdiff_t) {}
struct S_67_ {
    void foo_68_(ptrdiff_t);
}
static assert(S_67_.foo_68_.mangleof == "_ZN5S_67_7foo_68_El");

// // Combination of arguments for a struct member.
// struct S_69_ {
//     void foo_70_(S);
// };
// 
// void S_69_::foo_70_(S) {}
struct S_69_ {
    void foo_70_(S);
}
static assert(S_69_.foo_70_.mangleof == "_ZN5S_69_7foo_70_E1S");

// // Combination of arguments for a struct member.
// struct S_71_ {
//     void foo_72_(int*);
// };
// 
// void S_71_::foo_72_(int*) {}
struct S_71_ {
    void foo_72_(int*);
}
static assert(S_71_.foo_72_.mangleof == "_ZN5S_71_7foo_72_EPi");

// // Combination of arguments for a struct member.
// struct S_73_ {
//     void foo_74_(const int*);
// };
// 
// void S_73_::foo_74_(const int*) {}
struct S_73_ {
    void foo_74_(const(int)*);
}
static assert(S_73_.foo_74_.mangleof == "_ZN5S_73_7foo_74_EPKi");

// // Combination of arguments for a struct member.
// struct S_75_ {
//     void foo_76_(const int* const);
// };
// 
// void S_75_::foo_76_(const int* const) {}
struct S_75_ {
    void foo_76_(const(int*));
}
static assert(S_75_.foo_76_.mangleof == "_ZN5S_75_7foo_76_EPKi");

// // Combination of arguments for a struct member.
// struct S_77_ {
//     void foo_78_(S*);
// };
// 
// void S_77_::foo_78_(S*) {}
struct S_77_ {
    void foo_78_(S*);
}
static assert(S_77_.foo_78_.mangleof == "_ZN5S_77_7foo_78_EP1S");

// // Combination of arguments for a struct member.
// struct S_79_ {
//     void foo_80_(const S*);
// };
// 
// void S_79_::foo_80_(const S*) {}
struct S_79_ {
    void foo_80_(const(S)*);
}
static assert(S_79_.foo_80_.mangleof == "_ZN5S_79_7foo_80_EPK1S");

// // Combination of arguments for a struct member.
// struct S_81_ {
//     void foo_82_(const S* const);
// };
// 
// void S_81_::foo_82_(const S* const) {}
struct S_81_ {
    void foo_82_(const(S*));
}
static assert(S_81_.foo_82_.mangleof == "_ZN5S_81_7foo_82_EPK1S");

// // Combination of arguments for a struct member.
// struct S_83_ {
//     void foo_84_(int&);
// };
// 
// void S_83_::foo_84_(int&) {}
struct S_83_ {
    void foo_84_(ref int);
}
static assert(S_83_.foo_84_.mangleof == "_ZN5S_83_7foo_84_ERi");

// // Combination of arguments for a struct member.
// struct S_85_ {
//     void foo_86_(const int&);
// };
// 
// void S_85_::foo_86_(const int&) {}
struct S_85_ {
    void foo_86_(const ref int);
}
static assert(S_85_.foo_86_.mangleof == "_ZN5S_85_7foo_86_ERKi");

// // Combination of arguments for a struct member.
// struct S_87_ {
//     void foo_88_(S&);
// };
// 
// void S_87_::foo_88_(S&) {}
struct S_87_ {
    void foo_88_(ref S);
}
static assert(S_87_.foo_88_.mangleof == "_ZN5S_87_7foo_88_ER1S");

// // Combination of arguments for a struct member.
// struct S_89_ {
//     void foo_90_(const S&);
// };
// 
// void S_89_::foo_90_(const S&) {}
struct S_89_ {
    void foo_90_(const ref S);
}
static assert(S_89_.foo_90_.mangleof == "_ZN5S_89_7foo_90_ERK1S");

// // Combination of arguments for a struct member.
// struct S_91_ {
//     void foo_92_(void*(*)());
// };
// 
// void S_91_::foo_92_(void*(*)()) {}
struct S_91_ {
    void foo_92_(void* function());
}
static assert(S_91_.foo_92_.mangleof == "_ZN5S_91_7foo_92_EPFPvvE");

// // Combination of arguments for a struct member.
// struct S_93_ {
//     void foo_94_(int(*)(int));
// };
// 
// void S_93_::foo_94_(int(*)(int)) {}
struct S_93_ {
    void foo_94_(int function(int));
}
static assert(S_93_.foo_94_.mangleof == "_ZN5S_93_7foo_94_EPFiiE");

// // Combination of arguments for a struct member.
// struct S_95_ {
//     void foo_96_(void*(*)(), void*);
// };
// 
// void S_95_::foo_96_(void*(*)(), void*) {}
struct S_95_ {
    void foo_96_(void* function(), void*);
}
static assert(S_95_.foo_96_.mangleof == "_ZN5S_95_7foo_96_EPFPvvES0_");

// // Combination of arguments for a struct member.
// struct S_97_ {
//     void foo_98_(void(*)(void*), void*);
// };
// 
// void S_97_::foo_98_(void(*)(void*), void*) {}
struct S_97_ {
    void foo_98_(void function(void*), void*);
}
static assert(S_97_.foo_98_.mangleof == "_ZN5S_97_7foo_98_EPFvPvES0_");

// // Combination of arguments for a struct member.
// struct S_99_ {
//     void foo_100_(void*(*)(void**), void*);
// };
// 
// void S_99_::foo_100_(void*(*)(void**), void*) {}
struct S_99_ {
    void foo_100_(void* function(void**), void*);
}
static assert(S_99_.foo_100_.mangleof == "_ZN5S_99_8foo_100_EPFPvPS0_ES0_");

// // Combination of arguments for a struct member.
// struct S_101_ {
//     void foo_102_(void*(*)(void**), void**);
// };
// 
// void S_101_::foo_102_(void*(*)(void**), void**) {}
struct S_101_ {
    void foo_102_(void* function(void**), void**);
}
static assert(S_101_.foo_102_.mangleof == "_ZN6S_101_8foo_102_EPFPvPS0_ES1_");

// // Combination of arguments for a struct member.
// struct S_103_ {
//     void foo_104_(void*(*)(void*), void*(*)(void*));
// };
// 
// void S_103_::foo_104_(void*(*)(void*), void*(*)(void*)) {}
struct S_103_ {
    void foo_104_(void* function(void*), void* function(void*));
}
static assert(S_103_.foo_104_.mangleof == "_ZN6S_103_8foo_104_EPFPvS0_ES2_");

// // Combination of arguments for a const struct member.
// struct S_105_ {
//     void foo_106_() const;
// };
// 
// void S_105_::foo_106_() const {}
struct S_105_ {
    void foo_106_() const;
}
static assert(S_105_.foo_106_.mangleof == "_ZNK6S_105_8foo_106_Ev");

// // Combination of arguments for a const struct member.
// struct S_107_ {
//     void foo_108_(bool) const;
// };
// 
// void S_107_::foo_108_(bool) const {}
struct S_107_ {
    void foo_108_(bool) const;
}
static assert(S_107_.foo_108_.mangleof == "_ZNK6S_107_8foo_108_Eb");

// // Combination of arguments for a const struct member.
// struct S_109_ {
//     void foo_110_(signed char) const;
// };
// 
// void S_109_::foo_110_(signed char) const {}
struct S_109_ {
    void foo_110_(byte) const;
}
static assert(S_109_.foo_110_.mangleof == "_ZNK6S_109_8foo_110_Ea");

// // Combination of arguments for a const struct member.
// struct S_111_ {
//     void foo_112_(unsigned char) const;
// };
// 
// void S_111_::foo_112_(unsigned char) const {}
struct S_111_ {
    void foo_112_(ubyte) const;
}
static assert(S_111_.foo_112_.mangleof == "_ZNK6S_111_8foo_112_Eh");

// // Combination of arguments for a const struct member.
// struct S_113_ {
//     void foo_114_(char) const;
// };
// 
// void S_113_::foo_114_(char) const {}
struct S_113_ {
    void foo_114_(char) const;
}
static assert(S_113_.foo_114_.mangleof == "_ZNK6S_113_8foo_114_Ec");

// // Combination of arguments for a const struct member.
// struct S_115_ {
//     void foo_116_(wchar_t) const;
// };
// 
// void S_115_::foo_116_(wchar_t) const {}
struct S_115_ {
    void foo_116_(dchar) const;
}
static assert(S_115_.foo_116_.mangleof == "_ZNK6S_115_8foo_116_Ew");

// // Combination of arguments for a const struct member.
// struct S_117_ {
//     void foo_118_(short) const;
// };
// 
// void S_117_::foo_118_(short) const {}
struct S_117_ {
    void foo_118_(short) const;
}
static assert(S_117_.foo_118_.mangleof == "_ZNK6S_117_8foo_118_Es");

// // Combination of arguments for a const struct member.
// struct S_119_ {
//     void foo_120_(unsigned short) const;
// };
// 
// void S_119_::foo_120_(unsigned short) const {}
struct S_119_ {
    void foo_120_(ushort) const;
}
static assert(S_119_.foo_120_.mangleof == "_ZNK6S_119_8foo_120_Et");

// // Combination of arguments for a const struct member.
// struct S_121_ {
//     void foo_122_(int) const;
// };
// 
// void S_121_::foo_122_(int) const {}
struct S_121_ {
    void foo_122_(int) const;
}
static assert(S_121_.foo_122_.mangleof == "_ZNK6S_121_8foo_122_Ei");

// // Combination of arguments for a const struct member.
// struct S_123_ {
//     void foo_124_(unsigned int) const;
// };
// 
// void S_123_::foo_124_(unsigned int) const {}
struct S_123_ {
    void foo_124_(uint) const;
}
static assert(S_123_.foo_124_.mangleof == "_ZNK6S_123_8foo_124_Ej");

// // Combination of arguments for a const struct member.
// struct S_125_ {
//     void foo_126_(long) const;
// };
// 
// void S_125_::foo_126_(long) const {}
struct S_125_ {
    void foo_126_(core.stdc.config.c_long) const;
}
static assert(S_125_.foo_126_.mangleof == "_ZNK6S_125_8foo_126_El");

// // Combination of arguments for a const struct member.
// struct S_127_ {
//     void foo_128_(unsigned long) const;
// };
// 
// void S_127_::foo_128_(unsigned long) const {}
struct S_127_ {
    void foo_128_(core.stdc.config.c_ulong) const;
}
static assert(S_127_.foo_128_.mangleof == "_ZNK6S_127_8foo_128_Em");

// // Combination of arguments for a const struct member.
// struct S_129_ {
//     void foo_130_(float) const;
// };
// 
// void S_129_::foo_130_(float) const {}
struct S_129_ {
    void foo_130_(float) const;
}
static assert(S_129_.foo_130_.mangleof == "_ZNK6S_129_8foo_130_Ef");

// // Combination of arguments for a const struct member.
// struct S_131_ {
//     void foo_132_(double) const;
// };
// 
// void S_131_::foo_132_(double) const {}
struct S_131_ {
    void foo_132_(double) const;
}
static assert(S_131_.foo_132_.mangleof == "_ZNK6S_131_8foo_132_Ed");

// // Combination of arguments for a const struct member.
// struct S_133_ {
//     void foo_134_(long double) const;
// };
// 
// void S_133_::foo_134_(long double) const {}
struct S_133_ {
    void foo_134_(real) const;
}
static assert(S_133_.foo_134_.mangleof == "_ZNK6S_133_8foo_134_Ee");

// // Combination of arguments for a const struct member.
// struct S_135_ {
//     void foo_136_(size_t) const;
// };
// 
// void S_135_::foo_136_(size_t) const {}
struct S_135_ {
    void foo_136_(size_t) const;
}
static assert(S_135_.foo_136_.mangleof == "_ZNK6S_135_8foo_136_Em");

// // Combination of arguments for a const struct member.
// struct S_137_ {
//     void foo_138_(ptrdiff_t) const;
// };
// 
// void S_137_::foo_138_(ptrdiff_t) const {}
struct S_137_ {
    void foo_138_(ptrdiff_t) const;
}
static assert(S_137_.foo_138_.mangleof == "_ZNK6S_137_8foo_138_El");

// // Combination of arguments for a const struct member.
// struct S_139_ {
//     void foo_140_(S) const;
// };
// 
// void S_139_::foo_140_(S) const {}
struct S_139_ {
    void foo_140_(S) const;
}
static assert(S_139_.foo_140_.mangleof == "_ZNK6S_139_8foo_140_E1S");

// // Combination of arguments for a const struct member.
// struct S_141_ {
//     void foo_142_(int*) const;
// };
// 
// void S_141_::foo_142_(int*) const {}
struct S_141_ {
    void foo_142_(int*) const;
}
static assert(S_141_.foo_142_.mangleof == "_ZNK6S_141_8foo_142_EPi");

// // Combination of arguments for a const struct member.
// struct S_143_ {
//     void foo_144_(const int*) const;
// };
// 
// void S_143_::foo_144_(const int*) const {}
struct S_143_ {
    void foo_144_(const(int)*) const;
}
static assert(S_143_.foo_144_.mangleof == "_ZNK6S_143_8foo_144_EPKi");

// // Combination of arguments for a const struct member.
// struct S_145_ {
//     void foo_146_(const int* const) const;
// };
// 
// void S_145_::foo_146_(const int* const) const {}
struct S_145_ {
    void foo_146_(const(int*)) const;
}
static assert(S_145_.foo_146_.mangleof == "_ZNK6S_145_8foo_146_EPKi");

// // Combination of arguments for a const struct member.
// struct S_147_ {
//     void foo_148_(S*) const;
// };
// 
// void S_147_::foo_148_(S*) const {}
struct S_147_ {
    void foo_148_(S*) const;
}
static assert(S_147_.foo_148_.mangleof == "_ZNK6S_147_8foo_148_EP1S");

// // Combination of arguments for a const struct member.
// struct S_149_ {
//     void foo_150_(const S*) const;
// };
// 
// void S_149_::foo_150_(const S*) const {}
struct S_149_ {
    void foo_150_(const(S)*) const;
}
static assert(S_149_.foo_150_.mangleof == "_ZNK6S_149_8foo_150_EPK1S");

// // Combination of arguments for a const struct member.
// struct S_151_ {
//     void foo_152_(const S* const) const;
// };
// 
// void S_151_::foo_152_(const S* const) const {}
struct S_151_ {
    void foo_152_(const(S*)) const;
}
static assert(S_151_.foo_152_.mangleof == "_ZNK6S_151_8foo_152_EPK1S");

// // Combination of arguments for a const struct member.
// struct S_153_ {
//     void foo_154_(int&) const;
// };
// 
// void S_153_::foo_154_(int&) const {}
struct S_153_ {
    void foo_154_(ref int) const;
}
static assert(S_153_.foo_154_.mangleof == "_ZNK6S_153_8foo_154_ERi");

// // Combination of arguments for a const struct member.
// struct S_155_ {
//     void foo_156_(const int&) const;
// };
// 
// void S_155_::foo_156_(const int&) const {}
struct S_155_ {
    void foo_156_(const ref int) const;
}
static assert(S_155_.foo_156_.mangleof == "_ZNK6S_155_8foo_156_ERKi");

// // Combination of arguments for a const struct member.
// struct S_157_ {
//     void foo_158_(S&) const;
// };
// 
// void S_157_::foo_158_(S&) const {}
struct S_157_ {
    void foo_158_(ref S) const;
}
static assert(S_157_.foo_158_.mangleof == "_ZNK6S_157_8foo_158_ER1S");

// // Combination of arguments for a const struct member.
// struct S_159_ {
//     void foo_160_(const S&) const;
// };
// 
// void S_159_::foo_160_(const S&) const {}
struct S_159_ {
    void foo_160_(const ref S) const;
}
static assert(S_159_.foo_160_.mangleof == "_ZNK6S_159_8foo_160_ERK1S");

// // Combination of arguments for a const struct member.
// struct S_161_ {
//     void foo_162_(void*(*)()) const;
// };
// 
// void S_161_::foo_162_(void*(*)()) const {}
struct S_161_ {
    void foo_162_(void* function()) const;
}
static assert(S_161_.foo_162_.mangleof == "_ZNK6S_161_8foo_162_EPFPvvE");

// // Combination of arguments for a const struct member.
// struct S_163_ {
//     void foo_164_(int(*)(int)) const;
// };
// 
// void S_163_::foo_164_(int(*)(int)) const {}
struct S_163_ {
    void foo_164_(int function(int)) const;
}
static assert(S_163_.foo_164_.mangleof == "_ZNK6S_163_8foo_164_EPFiiE");

// // Combination of arguments for a const struct member.
// struct S_165_ {
//     void foo_166_(void*(*)(), void*) const;
// };
// 
// void S_165_::foo_166_(void*(*)(), void*) const {}
struct S_165_ {
    void foo_166_(void* function(), void*) const;
}
static assert(S_165_.foo_166_.mangleof == "_ZNK6S_165_8foo_166_EPFPvvES0_");

// // Combination of arguments for a const struct member.
// struct S_167_ {
//     void foo_168_(void(*)(void*), void*) const;
// };
// 
// void S_167_::foo_168_(void(*)(void*), void*) const {}
struct S_167_ {
    void foo_168_(void function(void*), void*) const;
}
static assert(S_167_.foo_168_.mangleof == "_ZNK6S_167_8foo_168_EPFvPvES0_");

// // Combination of arguments for a const struct member.
// struct S_169_ {
//     void foo_170_(void*(*)(void**), void*) const;
// };
// 
// void S_169_::foo_170_(void*(*)(void**), void*) const {}
struct S_169_ {
    void foo_170_(void* function(void**), void*) const;
}
static assert(S_169_.foo_170_.mangleof == "_ZNK6S_169_8foo_170_EPFPvPS0_ES0_");

// // Combination of arguments for a const struct member.
// struct S_171_ {
//     void foo_172_(void*(*)(void**), void**) const;
// };
// 
// void S_171_::foo_172_(void*(*)(void**), void**) const {}
struct S_171_ {
    void foo_172_(void* function(void**), void**) const;
}
static assert(S_171_.foo_172_.mangleof == "_ZNK6S_171_8foo_172_EPFPvPS0_ES1_");

// // Combination of arguments for a const struct member.
// struct S_173_ {
//     void foo_174_(void*(*)(void*), void*(*)(void*)) const;
// };
// 
// void S_173_::foo_174_(void*(*)(void*), void*(*)(void*)) const {}
struct S_173_ {
    void foo_174_(void* function(void*), void* function(void*)) const;
}
static assert(S_173_.foo_174_.mangleof == "_ZNK6S_173_8foo_174_EPFPvS0_ES2_");

// // simple templated function.
// template<typename T>
// void foo_175_(){};
// 
// template void foo_175_<bool>();
void foo_175_(T)();
static assert(foo_175_!(bool).mangleof == "_Z8foo_175_IbEvv");

// // simple templated function.
// template<typename T>
// void foo_176_(){};
// 
// template void foo_176_<char>();
void foo_176_(T)();
static assert(foo_176_!(char).mangleof == "_Z8foo_176_IcEvv");

// // simple templated function.
// template<typename T>
// void foo_177_(){};
// 
// template void foo_177_<int>();
void foo_177_(T)();
static assert(foo_177_!(int).mangleof == "_Z8foo_177_IiEvv");

// // simple templated function.
// template<typename T>
// void foo_178_(){};
// 
// template void foo_178_<float>();
void foo_178_(T)();
static assert(foo_178_!(float).mangleof == "_Z8foo_178_IfEvv");

// // simple templated function.
// template<typename T>
// void foo_179_(){};
// 
// template void foo_179_<double>();
void foo_179_(T)();
static assert(foo_179_!(double).mangleof == "_Z8foo_179_IdEvv");

// // simple templated function.
// template<typename T>
// void foo_180_(){};
// 
// template void foo_180_<const int>();
void foo_180_(T)();
static assert(foo_180_!(const int).mangleof == "_Z8foo_180_IKiEvv");

// // simple templated function.
// template<typename T>
// void foo_181_(){};
// 
// template void foo_181_<S>();
void foo_181_(T)();
static assert(foo_181_!(S).mangleof == "_Z8foo_181_I1SEvv");

// // simple templated function.
// template<typename T>
// void foo_182_(){};
// 
// template void foo_182_<S*>();
void foo_182_(T)();
static assert(foo_182_!(S*).mangleof == "_Z8foo_182_IP1SEvv");

// // simple templated function.
// template<typename T>
// void foo_183_(){};
// 
// template void foo_183_<const S>();
void foo_183_(T)();
static assert(foo_183_!(const S).mangleof == "_Z8foo_183_IK1SEvv");

// // simple templated function with return value.
// template<typename T>
// T* foo_184_(){ return nullptr; };
// 
// template bool* foo_184_<bool>();
T* foo_184_(T)();
static assert(foo_184_!(bool).mangleof == "_Z8foo_184_IbEPT_v");

// // simple templated function with return value.
// template<typename T>
// T* foo_185_(){ return nullptr; };
// 
// template char* foo_185_<char>();
T* foo_185_(T)();
static assert(foo_185_!(char).mangleof == "_Z8foo_185_IcEPT_v");

// // simple templated function with return value.
// template<typename T>
// T* foo_186_(){ return nullptr; };
// 
// template int* foo_186_<int>();
T* foo_186_(T)();
static assert(foo_186_!(int).mangleof == "_Z8foo_186_IiEPT_v");

// // simple templated function with return value.
// template<typename T>
// T* foo_187_(){ return nullptr; };
// 
// template float* foo_187_<float>();
T* foo_187_(T)();
static assert(foo_187_!(float).mangleof == "_Z8foo_187_IfEPT_v");

// // simple templated function with return value.
// template<typename T>
// T* foo_188_(){ return nullptr; };
// 
// template double* foo_188_<double>();
T* foo_188_(T)();
static assert(foo_188_!(double).mangleof == "_Z8foo_188_IdEPT_v");

// // simple templated function with return value.
// template<typename T>
// T* foo_189_(){ return nullptr; };
// 
// template const int* foo_189_<const int>();
T* foo_189_(T)();
static assert(foo_189_!(const int).mangleof == "_Z8foo_189_IKiEPT_v");

// // simple templated function with return value.
// template<typename T>
// T* foo_190_(){ return nullptr; };
// 
// template S* foo_190_<S>();
T* foo_190_(T)();
static assert(foo_190_!(S).mangleof == "_Z8foo_190_I1SEPT_v");

// // simple templated function with return value.
// template<typename T>
// T* foo_191_(){ return nullptr; };
// 
// template S** foo_191_<S*>();
T* foo_191_(T)();
static assert(foo_191_!(S*).mangleof == "_Z8foo_191_IP1SEPT_v");

// // simple templated function with return value.
// template<typename T>
// T* foo_192_(){ return nullptr; };
// 
// template const S* foo_192_<const S>();
T* foo_192_(T)();
static assert(foo_192_!(const S).mangleof == "_Z8foo_192_IK1SEPT_v");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_193_(T){ return nullptr; };
// 
// template bool* foo_193_<bool>(bool);
T* foo_193_(T)(T);
static assert(foo_193_!(bool).mangleof == "_Z8foo_193_IbEPT_S0_");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_194_(T){ return nullptr; };
// 
// template char* foo_194_<char>(char);
T* foo_194_(T)(T);
static assert(foo_194_!(char).mangleof == "_Z8foo_194_IcEPT_S0_");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_195_(T){ return nullptr; };
// 
// template int* foo_195_<int>(int);
T* foo_195_(T)(T);
static assert(foo_195_!(int).mangleof == "_Z8foo_195_IiEPT_S0_");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_196_(T){ return nullptr; };
// 
// template float* foo_196_<float>(float);
T* foo_196_(T)(T);
static assert(foo_196_!(float).mangleof == "_Z8foo_196_IfEPT_S0_");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_197_(T){ return nullptr; };
// 
// template double* foo_197_<double>(double);
T* foo_197_(T)(T);
static assert(foo_197_!(double).mangleof == "_Z8foo_197_IdEPT_S0_");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_198_(T){ return nullptr; };
// 
// template const int* foo_198_<const int>(const int);
T* foo_198_(T)(T);
static assert(foo_198_!(const int).mangleof == "_Z8foo_198_IKiEPT_S1_");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_199_(T){ return nullptr; };
// 
// template S* foo_199_<S>(S);
T* foo_199_(T)(T);
static assert(foo_199_!(S).mangleof == "_Z8foo_199_I1SEPT_S1_");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_200_(T){ return nullptr; };
// 
// template S** foo_200_<S*>(S*);
T* foo_200_(T)(T);
static assert(foo_200_!(S*).mangleof == "_Z8foo_200_IP1SEPT_S2_");

// // simple templated function with return value and argument.
// template<typename T>
// T* foo_201_(T){ return nullptr; };
// 
// template const S* foo_201_<const S>(const S);
T* foo_201_(T)(T);
static assert(foo_201_!(const S).mangleof == "_Z8foo_201_IK1SEPT_S2_");

// // templated function instanciated with templated type.
// template<typename T>
// struct S_202_{};
// 
// template<typename T>
// void foo_203_(){};
// 
// template void foo_203_<S_202_<S_202_<S_202_<int> > > >();
struct S_202_{}

void foo_203_(T)();
static assert(foo_203_!(S_202_!(S_202_!(S_202_!int))).mangleof == "_Z8foo_203_I6S_202_IS0_IS0_IiEEEEvv");

// // templated function with one argument instanciated with int.
// template<typename T>
// void foo_204_(T){};
// 
// template void foo_204_<int>(int);
void foo_204_(T)(T);
static assert(foo_204_!int.mangleof == "_Z8foo_204_IiEvT_");

// // templated function with three arguments.
// template<typename A, typename B, typename C>
// void foo_205_(A,B&,C){};
// 
// template void foo_205_<int,char,unsigned>(int,char&,unsigned);
void foo_205_(A,B,C)(A,ref B,C);
static assert(foo_205_!(int,char,uint).mangleof == "_Z8foo_205_IicjEvT_RT0_T1_");

}


extern(C++, a.b.c) {

// // function with a struct argument in a nested namespace.
// namespace a {
// namespace b {
// namespace c {
//  struct S_206_ {};
// void foo_207_(S_206_){} 
// } // namespace c 
// } // namespace b 
// } // namespace a
struct S_206_ {}
void foo_207_(S_206_){}
static assert(foo_207_.mangleof == "_ZN1a1b1c8foo_207_ENS1_6S_206_E");

// // templated function in a templated struct in a nested namespace.
// namespace a {
// namespace b {
// namespace c {
//  template<typename A>
// struct S_208_ {
//     template<typename B>
//     B* foo_209_(const B**) const;
// };
// 
// template<>
// template<>
// char* S_208_<int>::foo_209_<char>(const char**) const {
//     return nullptr;
// }; 
// } // namespace c 
// } // namespace b 
// } // namespace a
struct S_208_(A) {
    B* foo_209_(B)(const(B)**) const;
}
static assert(S_208_!int.foo_209_!char.mangleof == "_ZNK1a1b1c6S_208_IiE8foo_209_IcEEPT_PPKS5_");

// // templated function in a templated struct in a nested namespace.
// namespace a {
// namespace b {
// namespace c {
//  struct S2_211_ {};
// 
// template<typename A>
// struct S1_210_ {
//     template<typename B>
//     B* foo_212_(const B**) const;
// };
// 
// template<>
// template<>
// S2_211_* S1_210_<int>::foo_212_<S2_211_>(const S2_211_**) const {
//     return nullptr;
// }; 
// } // namespace c 
// } // namespace b 
// } // namespace a
struct S2_211_ {}

struct S1_210_(A) {
    B* foo_212_(B)(const(B)**) const;
}
static assert(S1_210_!int.foo_212_!S2_211_.mangleof == "_ZNK1a1b1c7S1_210_IiE8foo_212_INS1_7S2_211_EEEPT_PPKS6_");

}