Repository: RosettaCommons/binder (language: python)

Issue:
Added missing include
Added missing include.


Discussion / hints:

Fix patch:
diff --git a/source/binder.cpp b/source/binder.cpp
index 098d30ed..ce341637 100644
--- a/source/binder.cpp
+++ b/source/binder.cpp
@@ -258,9 +258,15 @@ int main(int argc, const char **argv)
 
 #else
 	//CommonOptionsParser op(argc, argv, BinderToolCategory);
-	llvm::Expected< CommonOptionsParser > eop = CommonOptionsParser::create(argc, argv, BinderToolCategory);
-	ClangTool tool(eop->getCompilations(), eop->getSourcePathList());
-	return tool.run(newFrontendActionFactory<BinderFrontendAction>().get());
+	if( llvm::Expected< CommonOptionsParser > eop = CommonOptionsParser::create(argc, argv, BinderToolCategory) ) {
+		ClangTool tool(eop->getCompilations(), eop->getSourcePathList());
+		return tool.run(newFrontendActionFactory<BinderFrontendAction>().get());
+	}
+	else {
+		auto errs = eop.takeError();
+		llvm::logAllUnhandledErrors(std::move(errs), outs(), "\nErrors:\n");
+		return 1;
+	}
 #endif
 
 }
diff --git a/source/class.cpp b/source/class.cpp
index 570306a9..6086d704 100644
--- a/source/class.cpp
+++ b/source/class.cpp
@@ -338,7 +338,10 @@ bool is_binding_requested(clang::CXXRecordDecl const *C, Config const &config)
 // check if user requested skipping for the given declaration
 bool is_skipping_requested(clang::CXXRecordDecl const *C, Config const &config)
 {
-	bool skip = config.is_class_skipping_requested( standard_name( C->getQualifiedNameAsString() ) ) or config.is_class_skipping_requested( class_qualified_name(C) ) or config.is_namespace_skipping_requested( namespace_from_named_decl(C) );
+	bool skip = \
+		config.is_class_skipping_requested( standard_name( C->getQualifiedNameAsString() ) ) or
+		config.is_class_skipping_requested( class_qualified_name(C) ) or
+		config.is_namespace_skipping_requested( namespace_from_named_decl(C) );
 
 	for(auto & t : get_type_dependencies(C) ) skip |= is_skipping_requested(t, config);
 
diff --git a/source/fmt/os.h b/source/fmt/os.h
index d44ea0c9..64f75d23 100644
--- a/source/fmt/os.h
+++ b/source/fmt/os.h
@@ -375,7 +375,7 @@ struct ostream_params {
 };
 }  // namespace detail
 
-static constexpr detail::buffer_size buffer_size;
+static constexpr detail::buffer_size buffer_size();
 
 // A fast output stream which is not thread-safe.
 class ostream final : private detail::buffer<char> {
diff --git a/source/type.cpp b/source/type.cpp
index 966b780f..5ad492e9 100644
--- a/source/type.cpp
+++ b/source/type.cpp
@@ -523,32 +523,40 @@ string simplify_std_class_name(string const &type)
 
 	if( regex_map.empty() ) {
 		vector< std::pair<string, string> > regex_arg_map = {
-			make_pair("^list<(.*),std::allocator<\\1>>$", "list<\\1>"),
-			make_pair("^deque<(.*),std::allocator<\\1>>$", "deque<\\1>"),
-			make_pair("^vector<(.*),std::allocator<\\1>>$", "vector<\\1>"),
-			make_pair("^set<(.*),std::less<\\1>,std::allocator<\\1>>$", "set<\\1>"),
-			make_pair("^forward_list<(.*),std::allocator<\\1>>$", "forward_list<\\1>"),
-			make_pair("^map<(.*),(.*),std::less<\\1>,std::allocator<std::pair<const \\1, \\2> >>$", "map<\\1,\\2>"),
+			make_pair("list<(.*), *std::allocator<\\1 *> *>", "list<\\1>"),
+			make_pair("deque<(.*), *std::allocator<\\1 *> *>", "deque<\\1>"),
 
-			make_pair("^multiset<(.*),std::less<(.*)>,std::allocator<(.*)>>$", "multiset<\\1>"),
-			make_pair("^multimap<(.*),(.*),std::less<\\1>,std::allocator<std::pair<const \\1, \\2> >>$", "multimap<\\1,\\2>"),
+			make_pair("vector<(.*), *std::allocator<\\1 *> *>", "vector<\\1>"),
+
+			make_pair("set<(.*), *std::less<\\1 *>, *std::allocator<\\1 *> *>", "set<\\1>"),
+			make_pair("forward_list<(.*), *std::allocator<\\1 *> *>", "forward_list<\\1>"),
+			make_pair("map<(.*),(.*), *std::less<\\1 *>, *std::allocator<std::pair<const \\1, \\2 *> *> *>", "map<\\1,\\2>"),
+
+			make_pair("multiset<(.*), *std::less<(.*)>, *std::allocator<(.*)>>", "multiset<\\1 *>"),
+			make_pair("multimap<(.*),(.*), *std::less<\\1>, *std::allocator<std::pair<const \\1, \\2 *> *> *>", "multimap<\\1,\\2>"),
 
 			// LLVM-3.7
 			//make_pair("^std::multimap<(.*),(.*),std::less<\\1>,std::allocator<std::pair<const \\1, \\2> >>", "multimap<\\1,\\2>"),
 
-			make_pair("^unordered_set<(.*),std::hash<\\1>,std::equal_to<\\1>,std::allocator<\\1>>$", "unordered_set<\\1>"),
-			make_pair("^unordered_map<(.*),(.*),std::hash<\\1>,std::equal_to<\\1>,std::allocator<std::pair<const \\1, \\2> >>$", "unordered_map<\\1,\\2>"),
+			make_pair("unordered_set<(.*), *std::hash<\\1>,std::equal_to<\\1>,std::allocator<\\1>>", "unordered_set<\\1>"),
+			make_pair("unordered_map<(.*), *(.*),std::hash<\\1>,std::equal_to<\\1>,std::allocator<std::pair<const \\1, \\2 *> *> *>", "unordered_map<\\1,\\2>"),
 
-			make_pair("^unordered_multiset<(.*),std::hash<\\1>,std::equal_to<\\1>,std::allocator<\\1>>$", "unordered_multiset<\\1>"),
-			make_pair("^unordered_multimap<(.*),(.*),std::hash<\\1>,std::equal_to<\\1>,std::allocator<std::pair<const \\1, \\2> >>$", "unordered_multimap<\\1,\\2>"),
+			make_pair("unordered_multiset<(.*), *std::hash<\\1>, *std::equal_to<\\1>, *std::allocator<\\1 *> *>", "unordered_multiset<\\1>"),
+			make_pair("unordered_multimap<(.*), *(.*),std::hash<\\1 *>, *std::equal_to<\\1 *>, *std::allocator<std::pair<const \\1, \\2 *> *> *>", "unordered_multimap<\\1,\\2>"),
 		};
 
 		for(auto & p : regex_arg_map) regex_map.emplace_back(llvm::Regex(p.first), p.second);
 	}
 
-	for(auto & p : regex_map) {
-		//llvm::Regex R(p.first);
-		res = p.first.sub(p.second, res);
+	int len = res.size(), previous_len = 0;
+
+	while( len != previous_len ) {
+		for(auto & p : regex_map) {
+			//llvm::Regex R(p.first);
+			res = p.first.sub(p.second, res);
+		}
+		previous_len = len;
+		len = res.size();
 	}
 
 	return res;


Test patch:
diff --git a/test/T15.inner_class.fwd.ref b/test/T15.inner_class.fwd.ref
index 19ebec64..213507ee 100644
--- a/test/T15.inner_class.fwd.ref
+++ b/test/T15.inner_class.fwd.ref
@@ -17,26 +17,26 @@
 
 void bind_T15_inner_class_fwd(std::function< pybind11::module &(std::string const &namespace_) > &M)
 {
-	{ // outer file:T15.inner_class.fwd.hpp line:11
-		pybind11::class_<outer, std::shared_ptr<outer>> cl(M(""), "outer", "binder/test/T15.inner_class.fwd.hpp\n \n\n  Binder self-test file. Tests for bindings of forward declared inner functions.\n \n\n Thomas Feierl");
+	{ // outer file:T15.inner_class.fwd.hpp line:10
+		pybind11::class_<outer, std::shared_ptr<outer>> cl(M(""), "outer", "binder/test/T15.inner_class.fwd.hpp\n \n\n  Binder self-test file. Tests for bindings of forward declared inner functions.");
 		cl.def( pybind11::init( [](){ return new outer(); } ) );
 		cl.def("f", (void (outer::*)(struct outer::inner *, struct outer::inner2 *, struct outer::inner3 *)) &outer::f, "C++: outer::f(struct outer::inner *, struct outer::inner2 *, struct outer::inner3 *) --> void", pybind11::arg("i"), pybind11::arg("i2"), pybind11::arg("i3"));
 
-		{ // outer::inner file:T15.inner_class.fwd.hpp line:13
+		{ // outer::inner file:T15.inner_class.fwd.hpp line:12
 			auto & enclosing_class = cl;
 			pybind11::class_<outer::inner, std::shared_ptr<outer::inner>> cl(enclosing_class, "inner", "");
 			cl.def( pybind11::init( [](){ return new outer::inner(); } ) );
 			cl.def_readwrite("a", &outer::inner::a);
 		}
 
-		{ // outer::inner2 file:T15.inner_class.fwd.hpp line:23
+		{ // outer::inner2 file:T15.inner_class.fwd.hpp line:22
 			auto & enclosing_class = cl;
 			pybind11::class_<outer::inner2, std::shared_ptr<outer::inner2>> cl(enclosing_class, "inner2", "");
 			cl.def( pybind11::init( [](){ return new outer::inner2(); } ) );
 			cl.def_readwrite("b", &outer::inner2::b);
 		}
 
-		{ // outer::inner3 file:T15.inner_class.fwd.hpp line:28
+		{ // outer::inner3 file:T15.inner_class.fwd.hpp line:27
 			auto & enclosing_class = cl;
 			pybind11::class_<outer::inner3, std::shared_ptr<outer::inner3>> cl(enclosing_class, "inner3", "");
 			cl.def( pybind11::init( [](){ return new outer::inner3(); } ) );
@@ -82,9 +82,9 @@ PYBIND11_MODULE(T15_inner_class_fwd, root_module) {
 
 }
 
-// Source list file: /home/thomas/Projects/thfe/binder/build/test//T15_inner_class_fwd.sources
+// Source list file: TEST/T15_inner_class_fwd.sources
 // T15_inner_class_fwd.cpp
 // T15_inner_class_fwd.cpp
 
-// Modules list file: /home/thomas/Projects/thfe/binder/build/test//T15_inner_class_fwd.modules
+// Modules list file: TEST/T15_inner_class_fwd.modules
 // 
diff --git a/test/T17.anonymous.ref b/test/T17.anonymous.ref
index 3a329e1f..c2e2eb2a 100644
--- a/test/T17.anonymous.ref
+++ b/test/T17.anonymous.ref
@@ -1,4 +1,6 @@
 // File: T17_anonymous.cpp
+#include <T17.anonymous.hpp> // Anonymous
+#include <T17.anonymous.hpp> // Anonymous::(anonymous)
 #include <T17.anonymous.hpp> // S
 #include <T17.anonymous.hpp> // S::_D
 #include <T17.anonymous.hpp> // _S2
@@ -42,14 +44,14 @@ void bind_T17_anonymous(std::function< pybind11::module &(std::string const &nam
 		pybind11::class_<_S2, std::shared_ptr<_S2>> cl(M(""), "_S2", "");
 		cl.def( pybind11::init( [](){ return new _S2(); } ) );
 		cl.def_readwrite("a", &_S2::a);
-	}	
+	}
 	{ // Anonymous file:T17.anonymous.hpp line:56
 		pybind11::class_<Anonymous, std::shared_ptr<Anonymous>> cl(M(""), "Anonymous", "");
-		cl.def( pybind11::init( [](){ return new Anonymous(); } ) );		
-		
-		{ // Anonymous::(anonymous) file: line:58
+		cl.def( pybind11::init( [](){ return new Anonymous(); } ) );
+
+		{ // Anonymous::(anonymous) file:T17.anonymous.hpp line:58
 
-			{ // Anonymous::(anonymous union)::(anonymous) file: line:60
+			{ // Anonymous::(anonymous union)::(anonymous) file:T17.anonymous.hpp line:60
 				cl.def_readwrite("x", &Anonymous::x);
 				cl.def_readwrite("y", &Anonymous::y);
 			}
diff --git a/test/T42.stl.names.hpp b/test/T42.stl.names.hpp
index 8163d6d9..a5605728 100644
--- a/test/T42.stl.names.hpp
+++ b/test/T42.stl.names.hpp
@@ -11,7 +11,7 @@
 /// @author Sergey Lyskov
 
 /// The multimap/multiset classes are tested in the binder/test/T43.stl.names.multi.hpp to avoid
-/// problems with different ordering of multiset/set and multimap/map bindings 
+/// problems with different ordering of multiset/set and multimap/map bindings
 /// in the generated files on different platforms.
 #ifndef _INCLUDED_T42_stl_names_hpp_
 #define _INCLUDED_T42_stl_names_hpp_
@@ -22,12 +22,15 @@
 #include <vector>
 #include <forward_list>
 
-
 void foo(std::list<double> ) {}
 void foo(std::forward_list<float> ) {}
 void foo(std::vector<double> ) {}
 void foo(std::deque<int> ) {}
 
+void foo(std::vector< std::vector<double> >) {}
+void foo(std::vector< std::vector< std::vector<double> > >) {}
+
+void foo(std::vector< std::list< std::forward_list< std::deque<double> > > >) {}
 
 
 #endif // _INCLUDED_T42_stl_names_hpp_
diff --git a/test/T42.stl.names.map.hpp b/test/T42.stl.names.map.hpp
index 2311c041..fcf6b7b2 100644
--- a/test/T42.stl.names.map.hpp
+++ b/test/T42.stl.names.map.hpp
@@ -11,7 +11,7 @@
 /// @author Sergey Lyskov
 
 /// The multimap/multiset classes are tested in the binder/test/T43.stl.names.multi.hpp to avoid
-/// problems with different ordering of multiset/set and multimap/map bindings 
+/// problems with different ordering of multiset/set and multimap/map bindings
 /// in the generated files on different platforms.
 #ifndef _INCLUDED_T42_stl_names_map_hpp_
 #define _INCLUDED_T42_stl_names_map_hpp_
@@ -20,9 +20,18 @@
 #include <map>
 #include <unordered_map>
 
+#include <string>
+#include <list>
+#include <vector>
+#include <deque>
+#include <vector>
+#include <forward_list>
+
 void foo(std::map<float,int> ) {}
 
 void foo(std::unordered_map<float,int> ) {}
 
+void foo(std::map<std::string, std::list< std::forward_list< std::deque< std::vector<double> > > > >) {}
+void foo(std::unordered_map<std::string, std::list< std::forward_list< std::deque< std::vector<double> > > > >) {}
 
 #endif // _INCLUDED_T42_stl_names_map_hpp_
diff --git a/test/T42.stl.names.map.ref b/test/T42.stl.names.map.ref
index 551d9550..2cbd2a64 100644
--- a/test/T42.stl.names.map.ref
+++ b/test/T42.stl.names.map.ref
@@ -7,7 +7,11 @@
 #include <functional> // std::binary_function
 #include <functional> // std::equal_to
 #include <functional> // std::less
+#include <iterator> // __gnu_cxx::__normal_iterator
+#include <memory> // std::allocator
 #include <sstream> // __str__
+#include <string> // std::basic_string
+#include <string> // std::char_traits
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -28,22 +32,36 @@ void bind_std_stl_function(std::function< pybind11::module &(std::string const &
 		cl.def( pybind11::init( [](){ return new std::binary_function<float,float,bool>(); } ) );
 		cl.def("assign", (struct std::binary_function<float, float, bool> & (std::binary_function<float,float,bool>::*)(const struct std::binary_function<float, float, bool> &)) &std::binary_function<float, float, bool>::operator=, "C++: std::binary_function<float, float, bool>::operator=(const struct std::binary_function<float, float, bool> &) --> struct std::binary_function<float, float, bool> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
 	}
+	{ // std::binary_function file:bits/stl_function.h line:114
+		pybind11::class_<std::binary_function<std::string,std::string,bool>, std::shared_ptr<std::binary_function<std::string,std::string,bool>>> cl(M("std"), "binary_function_std_string_std_string_bool_t", "");
+		cl.def( pybind11::init( [](std::binary_function<std::string,std::string,bool> const &o){ return new std::binary_function<std::string,std::string,bool>(o); } ) );
+		cl.def( pybind11::init( [](){ return new std::binary_function<std::string,std::string,bool>(); } ) );
+		cl.def("assign", (struct std::binary_function<std::string, std::string, bool> & (std::binary_function<std::string,std::string,bool>::*)(const struct std::binary_function<std::string, std::string, bool> &)) &std::binary_function<std::string, std::string, bool>::operator=, "C++: std::binary_function<std::string, std::string, bool>::operator=(const struct std::binary_function<std::string, std::string, bool> &) --> struct std::binary_function<std::string, std::string, bool> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+	}
 	{ // std::equal_to file:bits/stl_function.h line:204
 		pybind11::class_<std::equal_to<float>, std::shared_ptr<std::equal_to<float>>, std::binary_function<float,float,bool>> cl(M("std"), "equal_to_float_t", "");
 		cl.def( pybind11::init( [](){ return new std::equal_to<float>(); } ) );
 		cl.def("__call__", (bool (std::equal_to<float>::*)(const float &, const float &) const) &std::equal_to<float>::operator(), "C++: std::equal_to<float>::operator()(const float &, const float &) const --> bool", pybind11::arg("__x"), pybind11::arg("__y"));
 		cl.def("assign", (struct std::binary_function<float, float, bool> & (std::binary_function<float,float,bool>::*)(const struct std::binary_function<float, float, bool> &)) &std::binary_function<float, float, bool>::operator=, "C++: std::binary_function<float, float, bool>::operator=(const struct std::binary_function<float, float, bool> &) --> struct std::binary_function<float, float, bool> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
 	}
+	{ // std::equal_to file:bits/stl_function.h line:204
+		pybind11::class_<std::equal_to<std::string>, std::shared_ptr<std::equal_to<std::string>>, std::binary_function<std::string,std::string,bool>> cl(M("std"), "equal_to_std_string_t", "");
+		cl.def( pybind11::init( [](){ return new std::equal_to<std::string>(); } ) );
+		cl.def("__call__", (bool (std::equal_to<std::string>::*)(const std::string &, const std::string &) const) &std::equal_to<std::string >::operator(), "C++: std::equal_to<std::string >::operator()(const std::string &, const std::string &) const --> bool", pybind11::arg("__x"), pybind11::arg("__y"));
+		cl.def("assign", (struct std::binary_function<std::string, std::string, bool> & (std::binary_function<std::string,std::string,bool>::*)(const struct std::binary_function<std::string, std::string, bool> &)) &std::binary_function<std::string, std::string, bool>::operator=, "C++: std::binary_function<std::string, std::string, bool>::operator=(const struct std::binary_function<std::string, std::string, bool> &) --> struct std::binary_function<std::string, std::string, bool> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+	}
 }
 
 
 // File: std/functional_hash.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::_Manager_operation
 #include <functional> // std::bad_function_call
-#include <functional> // std::equal_to
 #include <functional> // std::hash
 #include <functional> // std::less
 #include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
 #include <map> // std::_Rb_tree_color
 #include <map> // std::_Rb_tree_const_iterator
 #include <map> // std::_Rb_tree_iterator
@@ -64,10 +82,8 @@ void bind_std_stl_function(std::function< pybind11::module &(std::string const &
 #include <string> // std::char_traits
 #include <string> // std::hash
 #include <tuple> // std::tuple
-#include <unordered_map> // std::__detail::_Node_const_iterator
-#include <unordered_map> // std::__detail::_Node_iterator
-#include <unordered_map> // std::unordered_map
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -89,6 +105,11 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 		cl.def("__call__", (unsigned long (std::hash<float>::*)(float) const) &std::hash<float>::operator(), "C++: std::hash<float>::operator()(float) const --> unsigned long", pybind11::arg("__val"));
 		cl.def("assign", (struct std::hash<float> & (std::hash<float>::*)(const struct std::hash<float> &)) &std::hash<float>::operator=, "C++: std::hash<float>::operator=(const struct std::hash<float> &) --> struct std::hash<float> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
 	}
+	{ // std::hash file:bits/basic_string.h line:3044
+		pybind11::class_<std::hash<std::string>, std::shared_ptr<std::hash<std::string>>> cl(M("std"), "hash_std_string_t", "");
+		cl.def( pybind11::init( [](){ return new std::hash<std::string>(); } ) );
+		cl.def("__call__", (unsigned long (std::hash<std::string>::*)(const std::string &) const) &std::hash<std::string >::operator(), "C++: std::hash<std::string >::operator()(const std::string &) const --> unsigned long", pybind11::arg("__s"));
+	}
 	{ // std::map file:bits/stl_map.h line:96
 		pybind11::class_<std::map<float,int>, std::shared_ptr<std::map<float,int>>> cl(M("std"), "map_float_int_t", "");
 		cl.def( pybind11::init( [](){ return new std::map<float,int>(); } ) );
@@ -111,6 +132,62 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 		cl.def("count", (unsigned long (std::map<float,int>::*)(const float &) const) &std::map<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::count, "C++: std::map<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::count(const float &) const --> unsigned long", pybind11::arg("__x"));
 		cl.def("equal_range", (struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const float, int> >, struct std::_Rb_tree_iterator<struct std::pair<const float, int> > > (std::map<float,int>::*)(const float &)) &std::map<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::equal_range, "C++: std::map<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::equal_range(const float &) --> struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const float, int> >, struct std::_Rb_tree_iterator<struct std::pair<const float, int> > >", pybind11::arg("__x"));
 	}
+	{ // std::map file:bits/stl_map.h line:96
+		pybind11::class_<std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>, std::shared_ptr<std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>>> cl(M("std"), "map_std_string_std_list_std_forward_list_std_deque_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(); } ) );
+		cl.def( pybind11::init( [](const struct std::less<std::string > & a0){ return new std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0); } ), "doc" , pybind11::arg("__comp"));
+		cl.def( pybind11::init<const struct std::less<std::string > &, const class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &>(), pybind11::arg("__comp"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>> const &o){ return new std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(o); } ) );
+		cl.def("assign", (class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > & (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=(const class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("get_allocator", (class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator() const --> class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >");
+		cl.def("empty", (bool (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty() const --> bool");
+		cl.def("size", (unsigned long (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size() const --> unsigned long");
+		cl.def("__getitem__", (class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > & (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &)) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator[], "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator[](const std::string &) --> class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__k"));
+		cl.def("at", (class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > & (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &)) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::at, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::at(const std::string &) --> class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__k"));
+		cl.def("insert", (struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >, bool> (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > &)) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::insert, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::insert(const struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > &) --> struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >, bool>", pybind11::arg("__x"));
+		cl.def("erase", (unsigned long (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &)) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase(const std::string &) --> unsigned long", pybind11::arg("__x"));
+		cl.def("swap", (void (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap(class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)()) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear() --> void");
+		cl.def("key_comp", (struct std::less<std::string > (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_comp, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_comp() const --> struct std::less<std::string >");
+		cl.def("count", (unsigned long (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &) const) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count(const std::string &) const --> unsigned long", pybind11::arg("__x"));
+		cl.def("equal_range", (struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >, struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > (std::map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &)) &std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range, "C++: std::map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range(const std::string &) --> struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >, struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >", pybind11::arg("__x"));
+	}
+}
+
+
+// File: std/unordered_map.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
+#include <functional> // std::equal_to
+#include <functional> // std::hash
+#include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
+#include <memory> // std::allocator
+#include <sstream> // __str__
+#include <string> // std::basic_string
+#include <string> // std::char_traits
+#include <string> // std::hash
+#include <unordered_map> // std::__detail::_Node_const_iterator
+#include <unordered_map> // std::__detail::_Node_iterator
+#include <unordered_map> // std::unordered_map
+#include <utility> // std::pair
+#include <vector> // std::vector
+
+#include <pybind11/pybind11.h>
+#include <functional>
+#include <string>
+
+#ifndef BINDER_PYBIND11_TYPE_CASTER
+	#define BINDER_PYBIND11_TYPE_CASTER
+	PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
+	PYBIND11_DECLARE_HOLDER_TYPE(T, T*)
+	PYBIND11_MAKE_OPAQUE(std::shared_ptr<void>)
+#endif
+
+void bind_std_unordered_map(std::function< pybind11::module &(std::string const &namespace_) > &M)
+{
 	{ // std::unordered_map file:bits/unordered_map.h line:97
 		pybind11::class_<std::unordered_map<float,int>, std::shared_ptr<std::unordered_map<float,int>>> cl(M("std"), "unordered_map_float_int_t", "");
 		cl.def( pybind11::init( [](){ return new std::unordered_map<float,int>(); } ), "doc" );
@@ -145,22 +222,113 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 		cl.def("rehash", (void (std::unordered_map<float,int>::*)(unsigned long)) &std::unordered_map<float, int, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, int> > >::rehash, "C++: std::unordered_map<float, int, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, int> > >::rehash(unsigned long) --> void", pybind11::arg("__n"));
 		cl.def("reserve", (void (std::unordered_map<float,int>::*)(unsigned long)) &std::unordered_map<float, int, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, int> > >::reserve, "C++: std::unordered_map<float, int, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, int> > >::reserve(unsigned long) --> void", pybind11::arg("__n"));
 	}
+	{ // std::unordered_map file:bits/unordered_map.h line:97
+		pybind11::class_<std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>, std::shared_ptr<std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>>> cl(M("std"), "unordered_map_std_string_std_list_std_forward_list_std_deque_std_vector_double_std_hash_std_string_std_equal_to_std_string_std_allocator_std_pair_const_std_string_std_list_std_forward_list_std_deque_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>(); } ), "doc" );
+		cl.def( pybind11::init( [](unsigned long const & a0){ return new std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>(a0); } ), "doc" , pybind11::arg("__n"));
+		cl.def( pybind11::init( [](unsigned long const & a0, const struct std::hash<std::string> & a1){ return new std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>(a0, a1); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__hf"));
+		cl.def( pybind11::init( [](unsigned long const & a0, const struct std::hash<std::string> & a1, const struct std::equal_to<std::string > & a2){ return new std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>(a0, a1, a2); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__hf"), pybind11::arg("__eql"));
+		cl.def( pybind11::init<unsigned long, const struct std::hash<std::string> &, const struct std::equal_to<std::string > &, const class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &>(), pybind11::arg("__n"), pybind11::arg("__hf"), pybind11::arg("__eql"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >> const &o){ return new std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>(o); } ) );
+		cl.def("assign", (class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > & (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(const class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=(const class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+		cl.def("get_allocator", (class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator() const --> class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >");
+		cl.def("empty", (bool (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty() const --> bool");
+		cl.def("size", (unsigned long (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size() const --> unsigned long");
+		cl.def("insert", (struct std::pair<struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true>, bool> (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(const struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > &)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::insert, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::insert(const struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > &) --> struct std::pair<struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true>, bool>", pybind11::arg("__x"));
+		cl.def("erase", (unsigned long (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(const std::string &)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase(const std::string &) --> unsigned long", pybind11::arg("__x"));
+		cl.def("clear", (void (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)()) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear() --> void");
+		cl.def("swap", (void (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap(class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("hash_function", (struct std::hash<std::string> (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::hash_function, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::hash_function() const --> struct std::hash<std::string>");
+		cl.def("key_eq", (struct std::equal_to<std::string > (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_eq, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_eq() const --> struct std::equal_to<std::string >");
+		cl.def("count", (unsigned long (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(const std::string &) const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count(const std::string &) const --> unsigned long", pybind11::arg("__x"));
+		cl.def("equal_range", (struct std::pair<struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true>, struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true> > (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(const std::string &)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range(const std::string &) --> struct std::pair<struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true>, struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true> >", pybind11::arg("__x"));
+		cl.def("__getitem__", (class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > & (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(const std::string &)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator[], "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator[](const std::string &) --> class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__k"));
+		cl.def("at", (class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > & (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(const std::string &)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::at, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::at(const std::string &) --> class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__k"));
+		cl.def("bucket_count", (unsigned long (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_count, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_count() const --> unsigned long");
+		cl.def("max_bucket_count", (unsigned long (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_bucket_count, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_bucket_count() const --> unsigned long");
+		cl.def("bucket_size", (unsigned long (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(unsigned long) const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_size, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_size(unsigned long) const --> unsigned long", pybind11::arg("__n"));
+		cl.def("bucket", (unsigned long (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(const std::string &) const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket(const std::string &) const --> unsigned long", pybind11::arg("__key"));
+		cl.def("load_factor", (float (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::load_factor, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::load_factor() const --> float");
+		cl.def("max_load_factor", (float (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)() const) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor() const --> float");
+		cl.def("max_load_factor", (void (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(float)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor(float) --> void", pybind11::arg("__z"));
+		cl.def("rehash", (void (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(unsigned long)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::rehash, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::rehash(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("reserve", (void (std::unordered_map<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>,std::hash<std::string>,std::equal_to<std::string >,std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > >>::*)(unsigned long)) &std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::reserve, "C++: std::unordered_map<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::reserve(unsigned long) --> void", pybind11::arg("__n"));
+	}
+}
+
+
+// File: std/stl_list.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
+#include <list> // std::list
+#include <memory> // std::allocator
+#include <sstream> // __str__
+#include <vector> // std::vector
+
+#include <pybind11/pybind11.h>
+#include <functional>
+#include <string>
+
+#ifndef BINDER_PYBIND11_TYPE_CASTER
+	#define BINDER_PYBIND11_TYPE_CASTER
+	PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
+	PYBIND11_DECLARE_HOLDER_TYPE(T, T*)
+	PYBIND11_MAKE_OPAQUE(std::shared_ptr<void>)
+#endif
+
+void bind_std_stl_list(std::function< pybind11::module &(std::string const &namespace_) > &M)
+{
+	{ // std::list file:bits/stl_list.h line:438
+		pybind11::class_<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::shared_ptr<std::list<std::forward_list<std::deque<std::vector<double>>>>>> cl(M("std"), "list_std_forward_list_std_deque_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::list<std::forward_list<std::deque<std::vector<double>>>>(); } ) );
+		cl.def( pybind11::init<const class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > &>(), pybind11::arg("__a") );
+
+		cl.def( pybind11::init<unsigned long>(), pybind11::arg("__n") );
+
+		cl.def( pybind11::init( [](std::list<std::forward_list<std::deque<std::vector<double>>>> const &o){ return new std::list<std::forward_list<std::deque<std::vector<double>>>>(o); } ) );
+		cl.def("assign", (class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > & (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)(const class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &)) &std::list<std::forward_list<std::deque<std::vector<double>>>>::operator=, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::operator=(const class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &) --> class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("get_allocator", (class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)() const) &std::list<std::forward_list<std::deque<std::vector<double>>>>::get_allocator, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::get_allocator() const --> class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >");
+		cl.def("empty", (bool (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)() const) &std::list<std::forward_list<std::deque<std::vector<double>>>>::empty, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::empty() const --> bool");
+		cl.def("size", (unsigned long (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)() const) &std::list<std::forward_list<std::deque<std::vector<double>>>>::size, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)() const) &std::list<std::forward_list<std::deque<std::vector<double>>>>::max_size, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::max_size() const --> unsigned long");
+		cl.def("resize", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)(unsigned long)) &std::list<std::forward_list<std::deque<std::vector<double>>>>::resize, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::resize(unsigned long) --> void", pybind11::arg("__new_size"));
+		cl.def("front", (class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > & (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)()) &std::list<std::forward_list<std::deque<std::vector<double>>>>::front, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::front() --> class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > &", pybind11::return_value_policy::automatic);
+		cl.def("back", (class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > & (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)()) &std::list<std::forward_list<std::deque<std::vector<double>>>>::back, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::back() --> class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > &", pybind11::return_value_policy::automatic);
+		cl.def("pop_front", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)()) &std::list<std::forward_list<std::deque<std::vector<double>>>>::pop_front, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::pop_front() --> void");
+		cl.def("pop_back", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)()) &std::list<std::forward_list<std::deque<std::vector<double>>>>::pop_back, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::pop_back() --> void");
+		cl.def("swap", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)(class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &)) &std::list<std::forward_list<std::deque<std::vector<double>>>>::swap, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::swap(class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)()) &std::list<std::forward_list<std::deque<std::vector<double>>>>::clear, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::clear() --> void");
+		cl.def("unique", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)()) &std::list<std::forward_list<std::deque<std::vector<double>>>>::unique, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::unique() --> void");
+		cl.def("merge", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)(class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &)) &std::list<std::forward_list<std::deque<std::vector<double>>>>::merge, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::merge(class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("reverse", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)()) &std::list<std::forward_list<std::deque<std::vector<double>>>>::reverse, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::reverse() --> void");
+		cl.def("sort", (void (std::list<std::forward_list<std::deque<std::vector<double>>>>::*)()) &std::list<std::forward_list<std::deque<std::vector<double>>>>::sort, "C++: std::list<std::forward_list<std::deque<std::vector<double>>>>::sort() --> void");
+	}
 }
 
 
 // File: T42_stl_names_map.cpp
 #include <T42.stl.names.map.hpp> // foo
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::equal_to
 #include <functional> // std::hash
 #include <functional> // std::less
+#include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
 #include <map> // std::_Rb_tree_const_iterator
 #include <map> // std::_Rb_tree_iterator
 #include <map> // std::map
 #include <memory> // std::allocator
+#include <string> // std::basic_string
+#include <string> // std::char_traits
+#include <string> // std::hash
 #include <unordered_map> // std::__detail::_Node_const_iterator
 #include <unordered_map> // std::__detail::_Node_iterator
 #include <unordered_map> // std::unordered_map
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -175,12 +343,18 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 
 void bind_T42_stl_names_map(std::function< pybind11::module &(std::string const &namespace_) > &M)
 {
-	// foo(class std::map<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.map.hpp line:23
+	// foo(class std::map<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.map.hpp line:29
 	M("").def("foo", (void (*)(class std::map<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >)) &foo, "C++: foo(class std::map<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) --> void", pybind11::arg(""));
 
-	// foo(class std::unordered_map<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.map.hpp line:25
+	// foo(class std::unordered_map<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.map.hpp line:31
 	M("").def("foo", (void (*)(class std::unordered_map<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >)) &foo, "C++: foo(class std::unordered_map<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) --> void", pybind11::arg(""));
 
+	// foo(class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) file:T42.stl.names.map.hpp line:33
+	M("").def("foo", (void (*)(class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >)) &foo, "C++: foo(class std::map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) --> void", pybind11::arg(""));
+
+	// foo(class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) file:T42.stl.names.map.hpp line:34
+	M("").def("foo", (void (*)(class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >)) &foo, "C++: foo(class std::unordered_map<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) --> void", pybind11::arg(""));
+
 }
 
 
@@ -196,6 +370,8 @@ typedef std::function< pybind11::module & (std::string const &) > ModuleGetter;
 
 void bind_std_stl_function(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_std_functional_hash(std::function< pybind11::module &(std::string const &namespace_) > &M);
+void bind_std_unordered_map(std::function< pybind11::module &(std::string const &namespace_) > &M);
+void bind_std_stl_list(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_T42_stl_names_map(std::function< pybind11::module &(std::string const &namespace_) > &M);
 
 
@@ -220,6 +396,8 @@ PYBIND11_MODULE(T42_stl_names_map, root_module) {
 
 	bind_std_stl_function(M);
 	bind_std_functional_hash(M);
+	bind_std_unordered_map(M);
+	bind_std_stl_list(M);
 	bind_T42_stl_names_map(M);
 
 }
@@ -228,6 +406,8 @@ PYBIND11_MODULE(T42_stl_names_map, root_module) {
 // T42_stl_names_map.cpp
 // std/stl_function.cpp
 // std/functional_hash.cpp
+// std/unordered_map.cpp
+// std/stl_list.cpp
 // T42_stl_names_map.cpp
 
 // Modules list file: TEST/T42_stl_names_map.modules
diff --git a/test/T42.stl.names.multi.hpp b/test/T42.stl.names.multi.hpp
index 49e9dd1a..3ae70ba9 100644
--- a/test/T42.stl.names.multi.hpp
+++ b/test/T42.stl.names.multi.hpp
@@ -11,7 +11,7 @@
 /// @author Sergey Lyskov/Andrii Verbytskyi
 
 /// This test is separated from the binder/test/T42.stl.names.hpp to avoid
-/// problems with different ordering of multiset/set and multimap/map bindings 
+/// problems with different ordering of multiset/set and multimap/map bindings
 /// in the generated files on different platforms.
 #ifndef _INCLUDED_T42_stl_names_multi_hpp_
 #define _INCLUDED_T42_stl_names_multi_hpp_
@@ -23,6 +23,10 @@
 #include <unordered_set>
 #include <unordered_map>
 
+#include <list>
+#include <deque>
+#include <vector>
+#include <forward_list>
 
 void foo(std::multimap<float, int> ) {}
 void foo(std::multiset<float> ) {}
@@ -30,4 +34,7 @@ void foo(std::multiset<float> ) {}
 void foo(std::unordered_multiset<float> ) {}
 void foo(std::unordered_multimap<float, int> ) {}
 
+void foo(std::multimap<std::string, std::list< std::forward_list< std::deque< std::vector<double> > > > >) {}
+void foo(std::unordered_multimap<std::string, std::list< std::forward_list< std::deque< std::vector<double> > > > >) {}
+
 #endif // _INCLUDED_T42_stl_names_multi_hpp_
diff --git a/test/T42.stl.names.multi.ref b/test/T42.stl.names.multi.ref
index 68a25f88..bb3da507 100644
--- a/test/T42.stl.names.multi.ref
+++ b/test/T42.stl.names.multi.ref
@@ -7,7 +7,11 @@
 #include <functional> // std::binary_function
 #include <functional> // std::equal_to
 #include <functional> // std::less
+#include <iterator> // __gnu_cxx::__normal_iterator
+#include <memory> // std::allocator
 #include <sstream> // __str__
+#include <string> // std::basic_string
+#include <string> // std::char_traits
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -28,21 +32,36 @@ void bind_std_stl_function(std::function< pybind11::module &(std::string const &
 		cl.def( pybind11::init( [](){ return new std::binary_function<float,float,bool>(); } ) );
 		cl.def("assign", (struct std::binary_function<float, float, bool> & (std::binary_function<float,float,bool>::*)(const struct std::binary_function<float, float, bool> &)) &std::binary_function<float, float, bool>::operator=, "C++: std::binary_function<float, float, bool>::operator=(const struct std::binary_function<float, float, bool> &) --> struct std::binary_function<float, float, bool> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
 	}
+	{ // std::binary_function file:bits/stl_function.h line:114
+		pybind11::class_<std::binary_function<std::string,std::string,bool>, std::shared_ptr<std::binary_function<std::string,std::string,bool>>> cl(M("std"), "binary_function_std_string_std_string_bool_t", "");
+		cl.def( pybind11::init( [](std::binary_function<std::string,std::string,bool> const &o){ return new std::binary_function<std::string,std::string,bool>(o); } ) );
+		cl.def( pybind11::init( [](){ return new std::binary_function<std::string,std::string,bool>(); } ) );
+		cl.def("assign", (struct std::binary_function<std::string, std::string, bool> & (std::binary_function<std::string,std::string,bool>::*)(const struct std::binary_function<std::string, std::string, bool> &)) &std::binary_function<std::string, std::string, bool>::operator=, "C++: std::binary_function<std::string, std::string, bool>::operator=(const struct std::binary_function<std::string, std::string, bool> &) --> struct std::binary_function<std::string, std::string, bool> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+	}
 	{ // std::equal_to file:bits/stl_function.h line:204
 		pybind11::class_<std::equal_to<float>, std::shared_ptr<std::equal_to<float>>, std::binary_function<float,float,bool>> cl(M("std"), "equal_to_float_t", "");
 		cl.def( pybind11::init( [](){ return new std::equal_to<float>(); } ) );
 		cl.def("__call__", (bool (std::equal_to<float>::*)(const float &, const float &) const) &std::equal_to<float>::operator(), "C++: std::equal_to<float>::operator()(const float &, const float &) const --> bool", pybind11::arg("__x"), pybind11::arg("__y"));
 		cl.def("assign", (struct std::binary_function<float, float, bool> & (std::binary_function<float,float,bool>::*)(const struct std::binary_function<float, float, bool> &)) &std::binary_function<float, float, bool>::operator=, "C++: std::binary_function<float, float, bool>::operator=(const struct std::binary_function<float, float, bool> &) --> struct std::binary_function<float, float, bool> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
 	}
+	{ // std::equal_to file:bits/stl_function.h line:204
+		pybind11::class_<std::equal_to<std::string>, std::shared_ptr<std::equal_to<std::string>>, std::binary_function<std::string,std::string,bool>> cl(M("std"), "equal_to_std_string_t", "");
+		cl.def( pybind11::init( [](){ return new std::equal_to<std::string>(); } ) );
+		cl.def("__call__", (bool (std::equal_to<std::string>::*)(const std::string &, const std::string &) const) &std::equal_to<std::string >::operator(), "C++: std::equal_to<std::string >::operator()(const std::string &, const std::string &) const --> bool", pybind11::arg("__x"), pybind11::arg("__y"));
+		cl.def("assign", (struct std::binary_function<std::string, std::string, bool> & (std::binary_function<std::string,std::string,bool>::*)(const struct std::binary_function<std::string, std::string, bool> &)) &std::binary_function<std::string, std::string, bool>::operator=, "C++: std::binary_function<std::string, std::string, bool>::operator=(const struct std::binary_function<std::string, std::string, bool> &) --> struct std::binary_function<std::string, std::string, bool> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+	}
 }
 
 
 // File: std/functional_hash.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::_Manager_operation
 #include <functional> // std::bad_function_call
 #include <functional> // std::hash
 #include <functional> // std::less
 #include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
 #include <map> // std::_Rb_tree_color
 #include <map> // std::_Rb_tree_const_iterator
 #include <map> // std::_Rb_tree_iterator
@@ -65,6 +84,7 @@ void bind_std_stl_function(std::function< pybind11::module &(std::string const &
 #include <string> // std::hash
 #include <tuple> // std::tuple
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -86,6 +106,11 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 		cl.def("__call__", (unsigned long (std::hash<float>::*)(float) const) &std::hash<float>::operator(), "C++: std::hash<float>::operator()(float) const --> unsigned long", pybind11::arg("__val"));
 		cl.def("assign", (struct std::hash<float> & (std::hash<float>::*)(const struct std::hash<float> &)) &std::hash<float>::operator=, "C++: std::hash<float>::operator=(const struct std::hash<float> &) --> struct std::hash<float> &", pybind11::return_value_policy::automatic, pybind11::arg(""));
 	}
+	{ // std::hash file:bits/basic_string.h line:3044
+		pybind11::class_<std::hash<std::string>, std::shared_ptr<std::hash<std::string>>> cl(M("std"), "hash_std_string_t", "");
+		cl.def( pybind11::init( [](){ return new std::hash<std::string>(); } ) );
+		cl.def("__call__", (unsigned long (std::hash<std::string>::*)(const std::string &) const) &std::hash<std::string >::operator(), "C++: std::hash<std::string >::operator()(const std::string &) const --> unsigned long", pybind11::arg("__s"));
+	}
 	{ // std::multiset file:bits/stl_multiset.h line:92
 		pybind11::class_<std::multiset<float>, std::shared_ptr<std::multiset<float>>> cl(M("std"), "multiset_float_t", "");
 		cl.def( pybind11::init( [](){ return new std::multiset<float>(); } ) );
@@ -125,6 +150,25 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 		cl.def("count", (unsigned long (std::multimap<float,int>::*)(const float &) const) &std::multimap<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::count, "C++: std::multimap<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::count(const float &) const --> unsigned long", pybind11::arg("__x"));
 		cl.def("equal_range", (struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const float, int> >, struct std::_Rb_tree_iterator<struct std::pair<const float, int> > > (std::multimap<float,int>::*)(const float &)) &std::multimap<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::equal_range, "C++: std::multimap<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::equal_range(const float &) --> struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const float, int> >, struct std::_Rb_tree_iterator<struct std::pair<const float, int> > >", pybind11::arg("__x"));
 	}
+	{ // std::multimap file:bits/stl_multimap.h line:95
+		pybind11::class_<std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>, std::shared_ptr<std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>>> cl(M("std"), "multimap_std_string_std_list_std_forward_list_std_deque_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(); } ) );
+		cl.def( pybind11::init( [](const struct std::less<std::string > & a0){ return new std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0); } ), "doc" , pybind11::arg("__comp"));
+		cl.def( pybind11::init<const struct std::less<std::string > &, const class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &>(), pybind11::arg("__comp"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>> const &o){ return new std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(o); } ) );
+		cl.def("assign", (class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > & (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=(const class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("get_allocator", (class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator() const --> class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >");
+		cl.def("empty", (bool (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty() const --> bool");
+		cl.def("size", (unsigned long (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size() const --> unsigned long");
+		cl.def("erase", (unsigned long (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &)) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase(const std::string &) --> unsigned long", pybind11::arg("__x"));
+		cl.def("swap", (void (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap(class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)()) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear() --> void");
+		cl.def("key_comp", (struct std::less<std::string > (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_comp, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_comp() const --> struct std::less<std::string >");
+		cl.def("count", (unsigned long (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &) const) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count(const std::string &) const --> unsigned long", pybind11::arg("__x"));
+		cl.def("equal_range", (struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >, struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > (std::multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &)) &std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range, "C++: std::multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range(const std::string &) --> struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >, struct std::_Rb_tree_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >", pybind11::arg("__x"));
+	}
 }
 
 
@@ -161,27 +205,27 @@ void bind_std_unordered_set(std::function< pybind11::module &(std::string const
 		cl.def( pybind11::init<unsigned long, const struct std::hash<float> &, const struct std::equal_to<float> &, const class std::allocator<float> &>(), pybind11::arg("__n"), pybind11::arg("__hf"), pybind11::arg("__eql"), pybind11::arg("__a") );
 
 		cl.def( pybind11::init( [](std::unordered_multiset<float> const &o){ return new std::unordered_multiset<float>(o); } ) );
-		cl.def("assign", (class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > & (std::unordered_multiset<float>::*)(const class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::operator=, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::operator=(const class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &) --> class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &", pybind11::return_value_policy::automatic, pybind11::arg(""));
-		cl.def("get_allocator", (class std::allocator<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::get_allocator, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::get_allocator() const --> class std::allocator<float>");
-		cl.def("empty", (bool (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::empty, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::empty() const --> bool");
-		cl.def("size", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::size, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::size() const --> unsigned long");
-		cl.def("max_size", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_size, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_size() const --> unsigned long");
-		cl.def("erase", (unsigned long (std::unordered_multiset<float>::*)(const float &)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::erase, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::erase(const float &) --> unsigned long", pybind11::arg("__x"));
-		cl.def("clear", (void (std::unordered_multiset<float>::*)()) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::clear, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::clear() --> void");
-		cl.def("swap", (void (std::unordered_multiset<float>::*)(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::swap, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::swap(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &) --> void", pybind11::arg("__x"));
-		cl.def("hash_function", (struct std::hash<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::hash_function, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::hash_function() const --> struct std::hash<float>");
-		cl.def("key_eq", (struct std::equal_to<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::key_eq, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::key_eq() const --> struct std::equal_to<float>");
-		cl.def("count", (unsigned long (std::unordered_multiset<float>::*)(const float &) const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::count, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::count(const float &) const --> unsigned long", pybind11::arg("__x"));
-		cl.def("equal_range", (struct std::pair<struct std::__detail::_Node_iterator<float, true, false>, struct std::__detail::_Node_iterator<float, true, false> > (std::unordered_multiset<float>::*)(const float &)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::equal_range, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::equal_range(const float &) --> struct std::pair<struct std::__detail::_Node_iterator<float, true, false>, struct std::__detail::_Node_iterator<float, true, false> >", pybind11::arg("__x"));
-		cl.def("bucket_count", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket_count, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket_count() const --> unsigned long");
-		cl.def("max_bucket_count", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_bucket_count, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_bucket_count() const --> unsigned long");
-		cl.def("bucket_size", (unsigned long (std::unordered_multiset<float>::*)(unsigned long) const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket_size, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket_size(unsigned long) const --> unsigned long", pybind11::arg("__n"));
-		cl.def("bucket", (unsigned long (std::unordered_multiset<float>::*)(const float &) const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket(const float &) const --> unsigned long", pybind11::arg("__key"));
-		cl.def("load_factor", (float (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::load_factor, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::load_factor() const --> float");
-		cl.def("max_load_factor", (float (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_load_factor, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_load_factor() const --> float");
-		cl.def("max_load_factor", (void (std::unordered_multiset<float>::*)(float)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_load_factor, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_load_factor(float) --> void", pybind11::arg("__z"));
-		cl.def("rehash", (void (std::unordered_multiset<float>::*)(unsigned long)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::rehash, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::rehash(unsigned long) --> void", pybind11::arg("__n"));
-		cl.def("reserve", (void (std::unordered_multiset<float>::*)(unsigned long)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::reserve, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::reserve(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("assign", (class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > & (std::unordered_multiset<float>::*)(const class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &)) &std::unordered_multiset<float>::operator=, "C++: std::unordered_multiset<float>::operator=(const class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &) --> class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+		cl.def("get_allocator", (class std::allocator<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::get_allocator, "C++: std::unordered_multiset<float>::get_allocator() const --> class std::allocator<float>");
+		cl.def("empty", (bool (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::empty, "C++: std::unordered_multiset<float>::empty() const --> bool");
+		cl.def("size", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::size, "C++: std::unordered_multiset<float>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::max_size, "C++: std::unordered_multiset<float>::max_size() const --> unsigned long");
+		cl.def("erase", (unsigned long (std::unordered_multiset<float>::*)(const float &)) &std::unordered_multiset<float>::erase, "C++: std::unordered_multiset<float>::erase(const float &) --> unsigned long", pybind11::arg("__x"));
+		cl.def("clear", (void (std::unordered_multiset<float>::*)()) &std::unordered_multiset<float>::clear, "C++: std::unordered_multiset<float>::clear() --> void");
+		cl.def("swap", (void (std::unordered_multiset<float>::*)(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &)) &std::unordered_multiset<float>::swap, "C++: std::unordered_multiset<float>::swap(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &) --> void", pybind11::arg("__x"));
+		cl.def("hash_function", (struct std::hash<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::hash_function, "C++: std::unordered_multiset<float>::hash_function() const --> struct std::hash<float>");
+		cl.def("key_eq", (struct std::equal_to<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::key_eq, "C++: std::unordered_multiset<float>::key_eq() const --> struct std::equal_to<float>");
+		cl.def("count", (unsigned long (std::unordered_multiset<float>::*)(const float &) const) &std::unordered_multiset<float>::count, "C++: std::unordered_multiset<float>::count(const float &) const --> unsigned long", pybind11::arg("__x"));
+		cl.def("equal_range", (struct std::pair<struct std::__detail::_Node_iterator<float, true, false>, struct std::__detail::_Node_iterator<float, true, false> > (std::unordered_multiset<float>::*)(const float &)) &std::unordered_multiset<float>::equal_range, "C++: std::unordered_multiset<float>::equal_range(const float &) --> struct std::pair<struct std::__detail::_Node_iterator<float, true, false>, struct std::__detail::_Node_iterator<float, true, false> >", pybind11::arg("__x"));
+		cl.def("bucket_count", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::bucket_count, "C++: std::unordered_multiset<float>::bucket_count() const --> unsigned long");
+		cl.def("max_bucket_count", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::max_bucket_count, "C++: std::unordered_multiset<float>::max_bucket_count() const --> unsigned long");
+		cl.def("bucket_size", (unsigned long (std::unordered_multiset<float>::*)(unsigned long) const) &std::unordered_multiset<float>::bucket_size, "C++: std::unordered_multiset<float>::bucket_size(unsigned long) const --> unsigned long", pybind11::arg("__n"));
+		cl.def("bucket", (unsigned long (std::unordered_multiset<float>::*)(const float &) const) &std::unordered_multiset<float>::bucket, "C++: std::unordered_multiset<float>::bucket(const float &) const --> unsigned long", pybind11::arg("__key"));
+		cl.def("load_factor", (float (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::load_factor, "C++: std::unordered_multiset<float>::load_factor() const --> float");
+		cl.def("max_load_factor", (float (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::max_load_factor, "C++: std::unordered_multiset<float>::max_load_factor() const --> float");
+		cl.def("max_load_factor", (void (std::unordered_multiset<float>::*)(float)) &std::unordered_multiset<float>::max_load_factor, "C++: std::unordered_multiset<float>::max_load_factor(float) --> void", pybind11::arg("__z"));
+		cl.def("rehash", (void (std::unordered_multiset<float>::*)(unsigned long)) &std::unordered_multiset<float>::rehash, "C++: std::unordered_multiset<float>::rehash(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("reserve", (void (std::unordered_multiset<float>::*)(unsigned long)) &std::unordered_multiset<float>::reserve, "C++: std::unordered_multiset<float>::reserve(unsigned long) --> void", pybind11::arg("__n"));
 	}
 	{ // std::unordered_multimap file:bits/unordered_map.h line:778
 		pybind11::class_<std::unordered_multimap<float,int>, std::shared_ptr<std::unordered_multimap<float,int>>> cl(M("std"), "unordered_multimap_float_int_t", "");
@@ -217,21 +261,93 @@ void bind_std_unordered_set(std::function< pybind11::module &(std::string const
 }
 
 
+// File: std/unordered_map.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
+#include <functional> // std::equal_to
+#include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
+#include <memory> // std::allocator
+#include <sstream> // __str__
+#include <string> // std::basic_string
+#include <string> // std::char_traits
+#include <string> // std::hash
+#include <unordered_map> // std::__detail::_Node_const_iterator
+#include <unordered_map> // std::__detail::_Node_iterator
+#include <unordered_map> // std::unordered_multimap
+#include <utility> // std::pair
+#include <vector> // std::vector
+
+#include <pybind11/pybind11.h>
+#include <functional>
+#include <string>
+
+#ifndef BINDER_PYBIND11_TYPE_CASTER
+	#define BINDER_PYBIND11_TYPE_CASTER
+	PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
+	PYBIND11_DECLARE_HOLDER_TYPE(T, T*)
+	PYBIND11_MAKE_OPAQUE(std::shared_ptr<void>)
+#endif
+
+void bind_std_unordered_map(std::function< pybind11::module &(std::string const &namespace_) > &M)
+{
+	{ // std::unordered_multimap file:bits/unordered_map.h line:778
+		pybind11::class_<std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>, std::shared_ptr<std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>>> cl(M("std"), "unordered_multimap_std_string_std_list_std_forward_list_std_deque_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(); } ), "doc" );
+		cl.def( pybind11::init( [](unsigned long const & a0){ return new std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0); } ), "doc" , pybind11::arg("__n"));
+		cl.def( pybind11::init( [](unsigned long const & a0, const struct std::hash<std::string> & a1){ return new std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0, a1); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__hf"));
+		cl.def( pybind11::init( [](unsigned long const & a0, const struct std::hash<std::string> & a1, const struct std::equal_to<std::string > & a2){ return new std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0, a1, a2); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__hf"), pybind11::arg("__eql"));
+		cl.def( pybind11::init<unsigned long, const struct std::hash<std::string> &, const struct std::equal_to<std::string > &, const class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &>(), pybind11::arg("__n"), pybind11::arg("__hf"), pybind11::arg("__eql"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>> const &o){ return new std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>(o); } ) );
+		cl.def("assign", (class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > & (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=(const class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+		cl.def("get_allocator", (class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator() const --> class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >");
+		cl.def("empty", (bool (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty() const --> bool");
+		cl.def("size", (unsigned long (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size() const --> unsigned long");
+		cl.def("erase", (unsigned long (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &)) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase(const std::string &) --> unsigned long", pybind11::arg("__x"));
+		cl.def("clear", (void (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)()) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear() --> void");
+		cl.def("swap", (void (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap(class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("hash_function", (struct std::hash<std::string> (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::hash_function, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::hash_function() const --> struct std::hash<std::string>");
+		cl.def("key_eq", (struct std::equal_to<std::string > (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_eq, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_eq() const --> struct std::equal_to<std::string >");
+		cl.def("count", (unsigned long (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &) const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count(const std::string &) const --> unsigned long", pybind11::arg("__x"));
+		cl.def("equal_range", (struct std::pair<struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true>, struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true> > (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &)) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range(const std::string &) --> struct std::pair<struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true>, struct std::__detail::_Node_iterator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, true> >", pybind11::arg("__x"));
+		cl.def("bucket_count", (unsigned long (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_count, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_count() const --> unsigned long");
+		cl.def("max_bucket_count", (unsigned long (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_bucket_count, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_bucket_count() const --> unsigned long");
+		cl.def("bucket_size", (unsigned long (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(unsigned long) const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_size, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_size(unsigned long) const --> unsigned long", pybind11::arg("__n"));
+		cl.def("bucket", (unsigned long (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const std::string &) const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket(const std::string &) const --> unsigned long", pybind11::arg("__key"));
+		cl.def("load_factor", (float (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::load_factor, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::load_factor() const --> float");
+		cl.def("max_load_factor", (float (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor() const --> float");
+		cl.def("max_load_factor", (void (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(float)) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor(float) --> void", pybind11::arg("__z"));
+		cl.def("rehash", (void (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(unsigned long)) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::rehash, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::rehash(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("reserve", (void (std::unordered_multimap<std::string,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(unsigned long)) &std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::reserve, "C++: std::unordered_multimap<std::string, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<std::string>, std::equal_to<std::string >, std::allocator<std::pair<const std::string, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::reserve(unsigned long) --> void", pybind11::arg("__n"));
+	}
+}
+
+
 // File: T42_stl_names_multi.cpp
 #include <T42.stl.names.multi.hpp> // foo
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::equal_to
 #include <functional> // std::hash
 #include <functional> // std::less
+#include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
 #include <map> // std::_Rb_tree_const_iterator
 #include <map> // std::_Rb_tree_iterator
 #include <map> // std::multimap
 #include <memory> // std::allocator
 #include <set> // std::multiset
+#include <string> // std::basic_string
+#include <string> // std::char_traits
+#include <string> // std::hash
 #include <unordered_map> // std::__detail::_Node_const_iterator
 #include <unordered_map> // std::__detail::_Node_iterator
 #include <unordered_map> // std::unordered_multimap
 #include <unordered_set> // std::unordered_multiset
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -246,18 +362,24 @@ void bind_std_unordered_set(std::function< pybind11::module &(std::string const
 
 void bind_T42_stl_names_multi(std::function< pybind11::module &(std::string const &namespace_) > &M)
 {
-	// foo(class std::multimap<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.multi.hpp line:27
+	// foo(class std::multimap<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.multi.hpp line:31
 	M("").def("foo", (void (*)(class std::multimap<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >)) &foo, "C++: foo(class std::multimap<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) --> void", pybind11::arg(""));
 
-	// foo(class std::multiset<float, struct std::less<float>, class std::allocator<float> >) file:T42.stl.names.multi.hpp line:28
+	// foo(class std::multiset<float, struct std::less<float>, class std::allocator<float> >) file:T42.stl.names.multi.hpp line:32
 	M("").def("foo", (void (*)(class std::multiset<float, struct std::less<float>, class std::allocator<float> >)) &foo, "C++: foo(class std::multiset<float, struct std::less<float>, class std::allocator<float> >) --> void", pybind11::arg(""));
 
-	// foo(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) file:T42.stl.names.multi.hpp line:30
+	// foo(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) file:T42.stl.names.multi.hpp line:34
 	M("").def("foo", (void (*)(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >)) &foo, "C++: foo(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) --> void", pybind11::arg(""));
 
-	// foo(class std::unordered_multimap<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.multi.hpp line:31
+	// foo(class std::unordered_multimap<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.multi.hpp line:35
 	M("").def("foo", (void (*)(class std::unordered_multimap<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >)) &foo, "C++: foo(class std::unordered_multimap<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) --> void", pybind11::arg(""));
 
+	// foo(class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) file:T42.stl.names.multi.hpp line:37
+	M("").def("foo", (void (*)(class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >)) &foo, "C++: foo(class std::multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) --> void", pybind11::arg(""));
+
+	// foo(class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) file:T42.stl.names.multi.hpp line:38
+	M("").def("foo", (void (*)(class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >)) &foo, "C++: foo(class std::unordered_multimap<std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<std::string>, struct std::equal_to<std::string >, class std::allocator<struct std::pair<const std::string, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) --> void", pybind11::arg(""));
+
 }
 
 
@@ -274,6 +396,7 @@ typedef std::function< pybind11::module & (std::string const &) > ModuleGetter;
 void bind_std_stl_function(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_std_functional_hash(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_std_unordered_set(std::function< pybind11::module &(std::string const &namespace_) > &M);
+void bind_std_unordered_map(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_T42_stl_names_multi(std::function< pybind11::module &(std::string const &namespace_) > &M);
 
 
@@ -299,6 +422,7 @@ PYBIND11_MODULE(T42_stl_names_multi, root_module) {
 	bind_std_stl_function(M);
 	bind_std_functional_hash(M);
 	bind_std_unordered_set(M);
+	bind_std_unordered_map(M);
 	bind_T42_stl_names_multi(M);
 
 }
@@ -308,6 +432,7 @@ PYBIND11_MODULE(T42_stl_names_multi, root_module) {
 // std/stl_function.cpp
 // std/functional_hash.cpp
 // std/unordered_set.cpp
+// std/unordered_map.cpp
 // T42_stl_names_multi.cpp
 
 // Modules list file: TEST/T42_stl_names_multi.modules
diff --git a/test/T42.stl.names.multimap.hpp b/test/T42.stl.names.multimap.hpp
index 4948344f..376698ba 100644
--- a/test/T42.stl.names.multimap.hpp
+++ b/test/T42.stl.names.multimap.hpp
@@ -11,7 +11,7 @@
 /// @author Sergey Lyskov/Andrii Verbytskyi
 
 /// This test is separated from the binder/test/T42.stl.names.hpp to avoid
-/// problems with different ordering of multiset/set and multimap/map bindings 
+/// problems with different ordering of multiset/set and multimap/map bindings
 /// in the generated files on different platforms.
 #ifndef _INCLUDED_T42_stl_names_multi_hpp_
 #define _INCLUDED_T42_stl_names_multi_hpp_
@@ -21,9 +21,16 @@
 #include <forward_list>
 #include <unordered_map>
 
+#include <list>
+#include <deque>
+#include <vector>
+#include <forward_list>
 
 void foo(std::multimap<float, int> ) {}
 
 void foo(std::unordered_multimap<float, int> ) {}
 
+void foo(std::multimap<float, std::list< std::forward_list< std::deque< std::vector<double> > > > > ) {}
+void foo(std::unordered_multimap<float, std::list< std::forward_list< std::deque< std::vector<double> > > > > ) {}
+
 #endif // _INCLUDED_T42_stl_names_multi_hpp_
diff --git a/test/T42.stl.names.multimap.ref b/test/T42.stl.names.multimap.ref
index 94b1fe71..91dda6d2 100644
--- a/test/T42.stl.names.multimap.ref
+++ b/test/T42.stl.names.multimap.ref
@@ -38,17 +38,22 @@ void bind_std_stl_function(std::function< pybind11::module &(std::string const &
 
 
 // File: std/functional_hash.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::_Manager_operation
 #include <functional> // std::bad_function_call
 #include <functional> // std::hash
 #include <functional> // std::less
 #include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
 #include <map> // std::_Rb_tree_color
 #include <map> // std::_Rb_tree_const_iterator
 #include <map> // std::_Rb_tree_iterator
 #include <map> // std::multimap
 #include <memory> // std::allocator
 #include <memory> // std::allocator_arg_t
+#include <memory> // std::allocator_traits
+#include <memory> // std::pointer_traits
 #include <sstream> // __str__
 #include <stdexcept> // std::domain_error
 #include <stdexcept> // std::invalid_argument
@@ -64,6 +69,7 @@ void bind_std_stl_function(std::function< pybind11::module &(std::string const &
 #include <string> // std::hash
 #include <tuple> // std::tuple
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -104,18 +110,41 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 		cl.def("count", (unsigned long (std::multimap<float,int>::*)(const float &) const) &std::multimap<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::count, "C++: std::multimap<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::count(const float &) const --> unsigned long", pybind11::arg("__x"));
 		cl.def("equal_range", (struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const float, int> >, struct std::_Rb_tree_iterator<struct std::pair<const float, int> > > (std::multimap<float,int>::*)(const float &)) &std::multimap<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::equal_range, "C++: std::multimap<float, int, std::less<float>, std::allocator<std::pair<const float, int> > >::equal_range(const float &) --> struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const float, int> >, struct std::_Rb_tree_iterator<struct std::pair<const float, int> > >", pybind11::arg("__x"));
 	}
+	{ // std::multimap file:bits/stl_multimap.h line:95
+		pybind11::class_<std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>, std::shared_ptr<std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>>> cl(M("std"), "multimap_float_std_list_std_forward_list_std_deque_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>(); } ) );
+		cl.def( pybind11::init( [](const struct std::less<float> & a0){ return new std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0); } ), "doc" , pybind11::arg("__comp"));
+		cl.def( pybind11::init<const struct std::less<float> &, const class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &>(), pybind11::arg("__comp"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>> const &o){ return new std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>(o); } ) );
+		cl.def("assign", (class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > & (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=(const class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("get_allocator", (class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator() const --> class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >");
+		cl.def("empty", (bool (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty() const --> bool");
+		cl.def("size", (unsigned long (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size() const --> unsigned long");
+		cl.def("erase", (unsigned long (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const float &)) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase(const float &) --> unsigned long", pybind11::arg("__x"));
+		cl.def("swap", (void (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap(class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)()) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear() --> void");
+		cl.def("key_comp", (struct std::less<float> (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_comp, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_comp() const --> struct std::less<float>");
+		cl.def("count", (unsigned long (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const float &) const) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count(const float &) const --> unsigned long", pybind11::arg("__x"));
+		cl.def("equal_range", (struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >, struct std::_Rb_tree_iterator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > (std::multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const float &)) &std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range, "C++: std::multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range(const float &) --> struct std::pair<struct std::_Rb_tree_iterator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >, struct std::_Rb_tree_iterator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >", pybind11::arg("__x"));
+	}
 }
 
 
 // File: std/unordered_map.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::equal_to
 #include <functional> // std::hash
+#include <list> // std::list
 #include <memory> // std::allocator
 #include <sstream> // __str__
 #include <unordered_map> // std::__detail::_Node_const_iterator
 #include <unordered_map> // std::__detail::_Node_iterator
 #include <unordered_map> // std::unordered_multimap
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -161,14 +190,48 @@ void bind_std_unordered_map(std::function< pybind11::module &(std::string const
 		cl.def("rehash", (void (std::unordered_multimap<float,int>::*)(unsigned long)) &std::unordered_multimap<float, int, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, int> > >::rehash, "C++: std::unordered_multimap<float, int, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, int> > >::rehash(unsigned long) --> void", pybind11::arg("__n"));
 		cl.def("reserve", (void (std::unordered_multimap<float,int>::*)(unsigned long)) &std::unordered_multimap<float, int, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, int> > >::reserve, "C++: std::unordered_multimap<float, int, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, int> > >::reserve(unsigned long) --> void", pybind11::arg("__n"));
 	}
+	{ // std::unordered_multimap file:bits/unordered_map.h line:778
+		pybind11::class_<std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>, std::shared_ptr<std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>>> cl(M("std"), "unordered_multimap_float_std_list_std_forward_list_std_deque_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>(); } ), "doc" );
+		cl.def( pybind11::init( [](unsigned long const & a0){ return new std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0); } ), "doc" , pybind11::arg("__n"));
+		cl.def( pybind11::init( [](unsigned long const & a0, const struct std::hash<float> & a1){ return new std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0, a1); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__hf"));
+		cl.def( pybind11::init( [](unsigned long const & a0, const struct std::hash<float> & a1, const struct std::equal_to<float> & a2){ return new std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>(a0, a1, a2); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__hf"), pybind11::arg("__eql"));
+		cl.def( pybind11::init<unsigned long, const struct std::hash<float> &, const struct std::equal_to<float> &, const class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &>(), pybind11::arg("__n"), pybind11::arg("__hf"), pybind11::arg("__eql"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>> const &o){ return new std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>(o); } ) );
+		cl.def("assign", (class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > & (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::operator=(const class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+		cl.def("get_allocator", (class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::get_allocator() const --> class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >");
+		cl.def("empty", (bool (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::empty() const --> bool");
+		cl.def("size", (unsigned long (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_size() const --> unsigned long");
+		cl.def("erase", (unsigned long (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const float &)) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::erase(const float &) --> unsigned long", pybind11::arg("__x"));
+		cl.def("clear", (void (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)()) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::clear() --> void");
+		cl.def("swap", (void (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &)) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::swap(class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("hash_function", (struct std::hash<float> (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::hash_function, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::hash_function() const --> struct std::hash<float>");
+		cl.def("key_eq", (struct std::equal_to<float> (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_eq, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::key_eq() const --> struct std::equal_to<float>");
+		cl.def("count", (unsigned long (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const float &) const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::count(const float &) const --> unsigned long", pybind11::arg("__x"));
+		cl.def("equal_range", (struct std::pair<struct std::__detail::_Node_iterator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, false>, struct std::__detail::_Node_iterator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, false> > (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const float &)) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::equal_range(const float &) --> struct std::pair<struct std::__detail::_Node_iterator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, false>, struct std::__detail::_Node_iterator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, false, false> >", pybind11::arg("__x"));
+		cl.def("bucket_count", (unsigned long (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_count, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_count() const --> unsigned long");
+		cl.def("max_bucket_count", (unsigned long (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_bucket_count, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_bucket_count() const --> unsigned long");
+		cl.def("bucket_size", (unsigned long (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(unsigned long) const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_size, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket_size(unsigned long) const --> unsigned long", pybind11::arg("__n"));
+		cl.def("bucket", (unsigned long (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(const float &) const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::bucket(const float &) const --> unsigned long", pybind11::arg("__key"));
+		cl.def("load_factor", (float (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::load_factor, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::load_factor() const --> float");
+		cl.def("max_load_factor", (float (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)() const) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor() const --> float");
+		cl.def("max_load_factor", (void (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(float)) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::max_load_factor(float) --> void", pybind11::arg("__z"));
+		cl.def("rehash", (void (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(unsigned long)) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::rehash, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::rehash(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("reserve", (void (std::unordered_multimap<float,std::list<std::forward_list<std::deque<std::vector<double>>>>>::*)(unsigned long)) &std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::reserve, "C++: std::unordered_multimap<float, std::list<std::forward_list<std::deque<std::vector<double>>>>, std::hash<float>, std::equal_to<float>, std::allocator<std::pair<const float, std::list<std::forward_list<std::deque<std::vector<double>>>> > > >::reserve(unsigned long) --> void", pybind11::arg("__n"));
+	}
 }
 
 
 // File: T42_stl_names_multimap.cpp
 #include <T42.stl.names.multimap.hpp> // foo
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::equal_to
 #include <functional> // std::hash
 #include <functional> // std::less
+#include <list> // std::list
 #include <map> // std::_Rb_tree_const_iterator
 #include <map> // std::_Rb_tree_iterator
 #include <map> // std::multimap
@@ -177,6 +240,7 @@ void bind_std_unordered_map(std::function< pybind11::module &(std::string const
 #include <unordered_map> // std::__detail::_Node_iterator
 #include <unordered_map> // std::unordered_multimap
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -191,12 +255,18 @@ void bind_std_unordered_map(std::function< pybind11::module &(std::string const
 
 void bind_T42_stl_names_multimap(std::function< pybind11::module &(std::string const &namespace_) > &M)
 {
-	// foo(class std::multimap<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.multimap.hpp line:25
+	// foo(class std::multimap<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.multimap.hpp line:29
 	M("").def("foo", (void (*)(class std::multimap<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >)) &foo, "C++: foo(class std::multimap<float, int, struct std::less<float>, class std::allocator<struct std::pair<const float, int> > >) --> void", pybind11::arg(""));
 
-	// foo(class std::unordered_multimap<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.multimap.hpp line:27
+	// foo(class std::unordered_multimap<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) file:T42.stl.names.multimap.hpp line:31
 	M("").def("foo", (void (*)(class std::unordered_multimap<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >)) &foo, "C++: foo(class std::unordered_multimap<float, int, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, int> > >) --> void", pybind11::arg(""));
 
+	// foo(class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) file:T42.stl.names.multimap.hpp line:33
+	M("").def("foo", (void (*)(class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >)) &foo, "C++: foo(class std::multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) --> void", pybind11::arg(""));
+
+	// foo(class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) file:T42.stl.names.multimap.hpp line:34
+	M("").def("foo", (void (*)(class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >)) &foo, "C++: foo(class std::unordered_multimap<float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<struct std::pair<const float, class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > >) --> void", pybind11::arg(""));
+
 }
 
 
diff --git a/test/T42.stl.names.multiset.hpp b/test/T42.stl.names.multiset.hpp
index 986eab84..16c26b8d 100644
--- a/test/T42.stl.names.multiset.hpp
+++ b/test/T42.stl.names.multiset.hpp
@@ -11,7 +11,7 @@
 /// @author Sergey Lyskov/Andrii Verbytskyi
 
 /// This test is separated from the binder/test/T42.stl.names.hpp to avoid
-/// problems with different ordering of multiset/set and multimap/map bindings 
+/// problems with different ordering of multiset/set and multimap/map bindings
 /// in the generated files on different platforms.
 #ifndef _INCLUDED_T42_stl_names_multiset_hpp_
 #define _INCLUDED_T42_stl_names_multiset_hpp_
@@ -21,9 +21,14 @@
 #include <forward_list>
 #include <unordered_set>
 
+#include <list>
+#include <deque>
+#include <vector>
+#include <forward_list>
 
 void foo(std::multiset<float> ) {}
 
 void foo(std::unordered_multiset<float> ) {}
 
+
 #endif // _INCLUDED_T42_stl_names_multiset_hpp_
diff --git a/test/T42.stl.names.multiset.ref b/test/T42.stl.names.multiset.ref
index 1cf6620b..e998c078 100644
--- a/test/T42.stl.names.multiset.ref
+++ b/test/T42.stl.names.multiset.ref
@@ -139,27 +139,27 @@ void bind_std_unordered_set(std::function< pybind11::module &(std::string const
 		cl.def( pybind11::init<unsigned long, const struct std::hash<float> &, const struct std::equal_to<float> &, const class std::allocator<float> &>(), pybind11::arg("__n"), pybind11::arg("__hf"), pybind11::arg("__eql"), pybind11::arg("__a") );
 
 		cl.def( pybind11::init( [](std::unordered_multiset<float> const &o){ return new std::unordered_multiset<float>(o); } ) );
-		cl.def("assign", (class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > & (std::unordered_multiset<float>::*)(const class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::operator=, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::operator=(const class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &) --> class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &", pybind11::return_value_policy::automatic, pybind11::arg(""));
-		cl.def("get_allocator", (class std::allocator<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::get_allocator, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::get_allocator() const --> class std::allocator<float>");
-		cl.def("empty", (bool (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::empty, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::empty() const --> bool");
-		cl.def("size", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::size, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::size() const --> unsigned long");
-		cl.def("max_size", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_size, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_size() const --> unsigned long");
-		cl.def("erase", (unsigned long (std::unordered_multiset<float>::*)(const float &)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::erase, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::erase(const float &) --> unsigned long", pybind11::arg("__x"));
-		cl.def("clear", (void (std::unordered_multiset<float>::*)()) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::clear, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::clear() --> void");
-		cl.def("swap", (void (std::unordered_multiset<float>::*)(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::swap, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::swap(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &) --> void", pybind11::arg("__x"));
-		cl.def("hash_function", (struct std::hash<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::hash_function, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::hash_function() const --> struct std::hash<float>");
-		cl.def("key_eq", (struct std::equal_to<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::key_eq, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::key_eq() const --> struct std::equal_to<float>");
-		cl.def("count", (unsigned long (std::unordered_multiset<float>::*)(const float &) const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::count, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::count(const float &) const --> unsigned long", pybind11::arg("__x"));
-		cl.def("equal_range", (struct std::pair<struct std::__detail::_Node_iterator<float, true, false>, struct std::__detail::_Node_iterator<float, true, false> > (std::unordered_multiset<float>::*)(const float &)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::equal_range, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::equal_range(const float &) --> struct std::pair<struct std::__detail::_Node_iterator<float, true, false>, struct std::__detail::_Node_iterator<float, true, false> >", pybind11::arg("__x"));
-		cl.def("bucket_count", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket_count, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket_count() const --> unsigned long");
-		cl.def("max_bucket_count", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_bucket_count, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_bucket_count() const --> unsigned long");
-		cl.def("bucket_size", (unsigned long (std::unordered_multiset<float>::*)(unsigned long) const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket_size, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket_size(unsigned long) const --> unsigned long", pybind11::arg("__n"));
-		cl.def("bucket", (unsigned long (std::unordered_multiset<float>::*)(const float &) const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::bucket(const float &) const --> unsigned long", pybind11::arg("__key"));
-		cl.def("load_factor", (float (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::load_factor, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::load_factor() const --> float");
-		cl.def("max_load_factor", (float (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_load_factor, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_load_factor() const --> float");
-		cl.def("max_load_factor", (void (std::unordered_multiset<float>::*)(float)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_load_factor, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::max_load_factor(float) --> void", pybind11::arg("__z"));
-		cl.def("rehash", (void (std::unordered_multiset<float>::*)(unsigned long)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::rehash, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::rehash(unsigned long) --> void", pybind11::arg("__n"));
-		cl.def("reserve", (void (std::unordered_multiset<float>::*)(unsigned long)) &std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::reserve, "C++: std::unordered_multiset<float, std::hash<float>, std::equal_to<float>, std::allocator<float> >::reserve(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("assign", (class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > & (std::unordered_multiset<float>::*)(const class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &)) &std::unordered_multiset<float>::operator=, "C++: std::unordered_multiset<float>::operator=(const class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &) --> class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &", pybind11::return_value_policy::automatic, pybind11::arg(""));
+		cl.def("get_allocator", (class std::allocator<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::get_allocator, "C++: std::unordered_multiset<float>::get_allocator() const --> class std::allocator<float>");
+		cl.def("empty", (bool (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::empty, "C++: std::unordered_multiset<float>::empty() const --> bool");
+		cl.def("size", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::size, "C++: std::unordered_multiset<float>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::max_size, "C++: std::unordered_multiset<float>::max_size() const --> unsigned long");
+		cl.def("erase", (unsigned long (std::unordered_multiset<float>::*)(const float &)) &std::unordered_multiset<float>::erase, "C++: std::unordered_multiset<float>::erase(const float &) --> unsigned long", pybind11::arg("__x"));
+		cl.def("clear", (void (std::unordered_multiset<float>::*)()) &std::unordered_multiset<float>::clear, "C++: std::unordered_multiset<float>::clear() --> void");
+		cl.def("swap", (void (std::unordered_multiset<float>::*)(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &)) &std::unordered_multiset<float>::swap, "C++: std::unordered_multiset<float>::swap(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> > &) --> void", pybind11::arg("__x"));
+		cl.def("hash_function", (struct std::hash<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::hash_function, "C++: std::unordered_multiset<float>::hash_function() const --> struct std::hash<float>");
+		cl.def("key_eq", (struct std::equal_to<float> (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::key_eq, "C++: std::unordered_multiset<float>::key_eq() const --> struct std::equal_to<float>");
+		cl.def("count", (unsigned long (std::unordered_multiset<float>::*)(const float &) const) &std::unordered_multiset<float>::count, "C++: std::unordered_multiset<float>::count(const float &) const --> unsigned long", pybind11::arg("__x"));
+		cl.def("equal_range", (struct std::pair<struct std::__detail::_Node_iterator<float, true, false>, struct std::__detail::_Node_iterator<float, true, false> > (std::unordered_multiset<float>::*)(const float &)) &std::unordered_multiset<float>::equal_range, "C++: std::unordered_multiset<float>::equal_range(const float &) --> struct std::pair<struct std::__detail::_Node_iterator<float, true, false>, struct std::__detail::_Node_iterator<float, true, false> >", pybind11::arg("__x"));
+		cl.def("bucket_count", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::bucket_count, "C++: std::unordered_multiset<float>::bucket_count() const --> unsigned long");
+		cl.def("max_bucket_count", (unsigned long (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::max_bucket_count, "C++: std::unordered_multiset<float>::max_bucket_count() const --> unsigned long");
+		cl.def("bucket_size", (unsigned long (std::unordered_multiset<float>::*)(unsigned long) const) &std::unordered_multiset<float>::bucket_size, "C++: std::unordered_multiset<float>::bucket_size(unsigned long) const --> unsigned long", pybind11::arg("__n"));
+		cl.def("bucket", (unsigned long (std::unordered_multiset<float>::*)(const float &) const) &std::unordered_multiset<float>::bucket, "C++: std::unordered_multiset<float>::bucket(const float &) const --> unsigned long", pybind11::arg("__key"));
+		cl.def("load_factor", (float (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::load_factor, "C++: std::unordered_multiset<float>::load_factor() const --> float");
+		cl.def("max_load_factor", (float (std::unordered_multiset<float>::*)() const) &std::unordered_multiset<float>::max_load_factor, "C++: std::unordered_multiset<float>::max_load_factor() const --> float");
+		cl.def("max_load_factor", (void (std::unordered_multiset<float>::*)(float)) &std::unordered_multiset<float>::max_load_factor, "C++: std::unordered_multiset<float>::max_load_factor(float) --> void", pybind11::arg("__z"));
+		cl.def("rehash", (void (std::unordered_multiset<float>::*)(unsigned long)) &std::unordered_multiset<float>::rehash, "C++: std::unordered_multiset<float>::rehash(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("reserve", (void (std::unordered_multiset<float>::*)(unsigned long)) &std::unordered_multiset<float>::reserve, "C++: std::unordered_multiset<float>::reserve(unsigned long) --> void", pybind11::arg("__n"));
 	}
 }
 
@@ -190,10 +190,10 @@ void bind_std_unordered_set(std::function< pybind11::module &(std::string const
 
 void bind_T42_stl_names_multiset(std::function< pybind11::module &(std::string const &namespace_) > &M)
 {
-	// foo(class std::multiset<float, struct std::less<float>, class std::allocator<float> >) file:T42.stl.names.multiset.hpp line:25
+	// foo(class std::multiset<float, struct std::less<float>, class std::allocator<float> >) file:T42.stl.names.multiset.hpp line:29
 	M("").def("foo", (void (*)(class std::multiset<float, struct std::less<float>, class std::allocator<float> >)) &foo, "C++: foo(class std::multiset<float, struct std::less<float>, class std::allocator<float> >) --> void", pybind11::arg(""));
 
-	// foo(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) file:T42.stl.names.multiset.hpp line:27
+	// foo(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) file:T42.stl.names.multiset.hpp line:31
 	M("").def("foo", (void (*)(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >)) &foo, "C++: foo(class std::unordered_multiset<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) --> void", pybind11::arg(""));
 
 }
diff --git a/test/T42.stl.names.ref b/test/T42.stl.names.ref
index 5ed5c955..66ab9af8 100644
--- a/test/T42.stl.names.ref
+++ b/test/T42.stl.names.ref
@@ -1,9 +1,13 @@
 // File: std/stl_list.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
+#include <iterator> // __gnu_cxx::__normal_iterator
 #include <list> // std::list
 #include <memory> // std::allocator
 #include <memory> // std::allocator_traits
 #include <memory> // std::pointer_traits
 #include <sstream> // __str__
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -23,31 +27,33 @@ void bind_std_stl_list(std::function< pybind11::module &(std::string const &name
 		cl.def( pybind11::init( [](){ return new std::list<double>(); } ) );
 		cl.def( pybind11::init<const class std::allocator<double> &>(), pybind11::arg("__a") );
 
+		cl.def( pybind11::init<unsigned long>(), pybind11::arg("__n") );
+
 		cl.def( pybind11::init( [](unsigned long const & a0, const double & a1){ return new std::list<double>(a0, a1); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__value"));
 		cl.def( pybind11::init<unsigned long, const double &, const class std::allocator<double> &>(), pybind11::arg("__n"), pybind11::arg("__value"), pybind11::arg("__a") );
 
 		cl.def( pybind11::init( [](std::list<double> const &o){ return new std::list<double>(o); } ) );
-		cl.def("assign", (class std::list<double, class std::allocator<double> > & (std::list<double>::*)(const class std::list<double, class std::allocator<double> > &)) &std::list<double, std::allocator<double> >::operator=, "C++: std::list<double, std::allocator<double> >::operator=(const class std::list<double, class std::allocator<double> > &) --> class std::list<double, class std::allocator<double> > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
-		cl.def("assign", (void (std::list<double>::*)(unsigned long, const double &)) &std::list<double, std::allocator<double> >::assign, "C++: std::list<double, std::allocator<double> >::assign(unsigned long, const double &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
-		cl.def("get_allocator", (class std::allocator<double> (std::list<double>::*)() const) &std::list<double, std::allocator<double> >::get_allocator, "C++: std::list<double, std::allocator<double> >::get_allocator() const --> class std::allocator<double>");
-		cl.def("empty", (bool (std::list<double>::*)() const) &std::list<double, std::allocator<double> >::empty, "C++: std::list<double, std::allocator<double> >::empty() const --> bool");
-		cl.def("size", (unsigned long (std::list<double>::*)() const) &std::list<double, std::allocator<double> >::size, "C++: std::list<double, std::allocator<double> >::size() const --> unsigned long");
-		cl.def("max_size", (unsigned long (std::list<double>::*)() const) &std::list<double, std::allocator<double> >::max_size, "C++: std::list<double, std::allocator<double> >::max_size() const --> unsigned long");
-		cl.def("resize", (void (std::list<double>::*)(unsigned long)) &std::list<double, std::allocator<double> >::resize, "C++: std::list<double, std::allocator<double> >::resize(unsigned long) --> void", pybind11::arg("__new_size"));
-		cl.def("resize", (void (std::list<double>::*)(unsigned long, const double &)) &std::list<double, std::allocator<double> >::resize, "C++: std::list<double, std::allocator<double> >::resize(unsigned long, const double &) --> void", pybind11::arg("__new_size"), pybind11::arg("__x"));
-		cl.def("front", (double & (std::list<double>::*)()) &std::list<double, std::allocator<double> >::front, "C++: std::list<double, std::allocator<double> >::front() --> double &", pybind11::return_value_policy::automatic);
-		cl.def("back", (double & (std::list<double>::*)()) &std::list<double, std::allocator<double> >::back, "C++: std::list<double, std::allocator<double> >::back() --> double &", pybind11::return_value_policy::automatic);
-		cl.def("push_front", (void (std::list<double>::*)(const double &)) &std::list<double, std::allocator<double> >::push_front, "C++: std::list<double, std::allocator<double> >::push_front(const double &) --> void", pybind11::arg("__x"));
-		cl.def("pop_front", (void (std::list<double>::*)()) &std::list<double, std::allocator<double> >::pop_front, "C++: std::list<double, std::allocator<double> >::pop_front() --> void");
-		cl.def("push_back", (void (std::list<double>::*)(const double &)) &std::list<double, std::allocator<double> >::push_back, "C++: std::list<double, std::allocator<double> >::push_back(const double &) --> void", pybind11::arg("__x"));
-		cl.def("pop_back", (void (std::list<double>::*)()) &std::list<double, std::allocator<double> >::pop_back, "C++: std::list<double, std::allocator<double> >::pop_back() --> void");
-		cl.def("swap", (void (std::list<double>::*)(class std::list<double, class std::allocator<double> > &)) &std::list<double, std::allocator<double> >::swap, "C++: std::list<double, std::allocator<double> >::swap(class std::list<double, class std::allocator<double> > &) --> void", pybind11::arg("__x"));
-		cl.def("clear", (void (std::list<double>::*)()) &std::list<double, std::allocator<double> >::clear, "C++: std::list<double, std::allocator<double> >::clear() --> void");
-		cl.def("remove", (void (std::list<double>::*)(const double &)) &std::list<double, std::allocator<double> >::remove, "C++: std::list<double, std::allocator<double> >::remove(const double &) --> void", pybind11::arg("__value"));
-		cl.def("unique", (void (std::list<double>::*)()) &std::list<double, std::allocator<double> >::unique, "C++: std::list<double, std::allocator<double> >::unique() --> void");
-		cl.def("merge", (void (std::list<double>::*)(class std::list<double, class std::allocator<double> > &)) &std::list<double, std::allocator<double> >::merge, "C++: std::list<double, std::allocator<double> >::merge(class std::list<double, class std::allocator<double> > &) --> void", pybind11::arg("__x"));
-		cl.def("reverse", (void (std::list<double>::*)()) &std::list<double, std::allocator<double> >::reverse, "C++: std::list<double, std::allocator<double> >::reverse() --> void");
-		cl.def("sort", (void (std::list<double>::*)()) &std::list<double, std::allocator<double> >::sort, "C++: std::list<double, std::allocator<double> >::sort() --> void");
+		cl.def("assign", (class std::list<double, class std::allocator<double> > & (std::list<double>::*)(const class std::list<double, class std::allocator<double> > &)) &std::list<double>::operator=, "C++: std::list<double>::operator=(const class std::list<double, class std::allocator<double> > &) --> class std::list<double, class std::allocator<double> > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("assign", (void (std::list<double>::*)(unsigned long, const double &)) &std::list<double>::assign, "C++: std::list<double>::assign(unsigned long, const double &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
+		cl.def("get_allocator", (class std::allocator<double> (std::list<double>::*)() const) &std::list<double>::get_allocator, "C++: std::list<double>::get_allocator() const --> class std::allocator<double>");
+		cl.def("empty", (bool (std::list<double>::*)() const) &std::list<double>::empty, "C++: std::list<double>::empty() const --> bool");
+		cl.def("size", (unsigned long (std::list<double>::*)() const) &std::list<double>::size, "C++: std::list<double>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::list<double>::*)() const) &std::list<double>::max_size, "C++: std::list<double>::max_size() const --> unsigned long");
+		cl.def("resize", (void (std::list<double>::*)(unsigned long)) &std::list<double>::resize, "C++: std::list<double>::resize(unsigned long) --> void", pybind11::arg("__new_size"));
+		cl.def("resize", (void (std::list<double>::*)(unsigned long, const double &)) &std::list<double>::resize, "C++: std::list<double>::resize(unsigned long, const double &) --> void", pybind11::arg("__new_size"), pybind11::arg("__x"));
+		cl.def("front", (double & (std::list<double>::*)()) &std::list<double>::front, "C++: std::list<double>::front() --> double &", pybind11::return_value_policy::automatic);
+		cl.def("back", (double & (std::list<double>::*)()) &std::list<double>::back, "C++: std::list<double>::back() --> double &", pybind11::return_value_policy::automatic);
+		cl.def("push_front", (void (std::list<double>::*)(const double &)) &std::list<double>::push_front, "C++: std::list<double>::push_front(const double &) --> void", pybind11::arg("__x"));
+		cl.def("pop_front", (void (std::list<double>::*)()) &std::list<double>::pop_front, "C++: std::list<double>::pop_front() --> void");
+		cl.def("push_back", (void (std::list<double>::*)(const double &)) &std::list<double>::push_back, "C++: std::list<double>::push_back(const double &) --> void", pybind11::arg("__x"));
+		cl.def("pop_back", (void (std::list<double>::*)()) &std::list<double>::pop_back, "C++: std::list<double>::pop_back() --> void");
+		cl.def("swap", (void (std::list<double>::*)(class std::list<double, class std::allocator<double> > &)) &std::list<double>::swap, "C++: std::list<double>::swap(class std::list<double, class std::allocator<double> > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::list<double>::*)()) &std::list<double>::clear, "C++: std::list<double>::clear() --> void");
+		cl.def("remove", (void (std::list<double>::*)(const double &)) &std::list<double>::remove, "C++: std::list<double>::remove(const double &) --> void", pybind11::arg("__value"));
+		cl.def("unique", (void (std::list<double>::*)()) &std::list<double>::unique, "C++: std::list<double>::unique() --> void");
+		cl.def("merge", (void (std::list<double>::*)(class std::list<double, class std::allocator<double> > &)) &std::list<double>::merge, "C++: std::list<double>::merge(class std::list<double, class std::allocator<double> > &) --> void", pybind11::arg("__x"));
+		cl.def("reverse", (void (std::list<double>::*)()) &std::list<double>::reverse, "C++: std::list<double>::reverse() --> void");
+		cl.def("sort", (void (std::list<double>::*)()) &std::list<double>::sort, "C++: std::list<double>::sort() --> void");
 	}
 }
 
@@ -77,29 +83,31 @@ void bind_std_stl_deque(std::function< pybind11::module &(std::string const &nam
 		cl.def( pybind11::init( [](){ return new std::deque<int>(); } ) );
 		cl.def( pybind11::init<const class std::allocator<int> &>(), pybind11::arg("__a") );
 
+		cl.def( pybind11::init<unsigned long>(), pybind11::arg("__n") );
+
 		cl.def( pybind11::init( [](unsigned long const & a0, const int & a1){ return new std::deque<int>(a0, a1); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__value"));
 		cl.def( pybind11::init<unsigned long, const int &, const class std::allocator<int> &>(), pybind11::arg("__n"), pybind11::arg("__value"), pybind11::arg("__a") );
 
 		cl.def( pybind11::init( [](std::deque<int> const &o){ return new std::deque<int>(o); } ) );
-		cl.def("assign", (class std::deque<int, class std::allocator<int> > & (std::deque<int>::*)(const class std::deque<int, class std::allocator<int> > &)) &std::deque<int, std::allocator<int> >::operator=, "C++: std::deque<int, std::allocator<int> >::operator=(const class std::deque<int, class std::allocator<int> > &) --> class std::deque<int, class std::allocator<int> > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
-		cl.def("assign", (void (std::deque<int>::*)(unsigned long, const int &)) &std::deque<int, std::allocator<int> >::assign, "C++: std::deque<int, std::allocator<int> >::assign(unsigned long, const int &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
-		cl.def("get_allocator", (class std::allocator<int> (std::deque<int>::*)() const) &std::deque<int, std::allocator<int> >::get_allocator, "C++: std::deque<int, std::allocator<int> >::get_allocator() const --> class std::allocator<int>");
-		cl.def("size", (unsigned long (std::deque<int>::*)() const) &std::deque<int, std::allocator<int> >::size, "C++: std::deque<int, std::allocator<int> >::size() const --> unsigned long");
-		cl.def("max_size", (unsigned long (std::deque<int>::*)() const) &std::deque<int, std::allocator<int> >::max_size, "C++: std::deque<int, std::allocator<int> >::max_size() const --> unsigned long");
-		cl.def("resize", (void (std::deque<int>::*)(unsigned long)) &std::deque<int, std::allocator<int> >::resize, "C++: std::deque<int, std::allocator<int> >::resize(unsigned long) --> void", pybind11::arg("__new_size"));
-		cl.def("resize", (void (std::deque<int>::*)(unsigned long, const int &)) &std::deque<int, std::allocator<int> >::resize, "C++: std::deque<int, std::allocator<int> >::resize(unsigned long, const int &) --> void", pybind11::arg("__new_size"), pybind11::arg("__x"));
-		cl.def("shrink_to_fit", (void (std::deque<int>::*)()) &std::deque<int, std::allocator<int> >::shrink_to_fit, "C++: std::deque<int, std::allocator<int> >::shrink_to_fit() --> void");
-		cl.def("empty", (bool (std::deque<int>::*)() const) &std::deque<int, std::allocator<int> >::empty, "C++: std::deque<int, std::allocator<int> >::empty() const --> bool");
-		cl.def("__getitem__", (int & (std::deque<int>::*)(unsigned long)) &std::deque<int, std::allocator<int> >::operator[], "C++: std::deque<int, std::allocator<int> >::operator[](unsigned long) --> int &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
-		cl.def("at", (int & (std::deque<int>::*)(unsigned long)) &std::deque<int, std::allocator<int> >::at, "C++: std::deque<int, std::allocator<int> >::at(unsigned long) --> int &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
-		cl.def("front", (int & (std::deque<int>::*)()) &std::deque<int, std::allocator<int> >::front, "C++: std::deque<int, std::allocator<int> >::front() --> int &", pybind11::return_value_policy::automatic);
-		cl.def("back", (int & (std::deque<int>::*)()) &std::deque<int, std::allocator<int> >::back, "C++: std::deque<int, std::allocator<int> >::back() --> int &", pybind11::return_value_policy::automatic);
-		cl.def("push_front", (void (std::deque<int>::*)(const int &)) &std::deque<int, std::allocator<int> >::push_front, "C++: std::deque<int, std::allocator<int> >::push_front(const int &) --> void", pybind11::arg("__x"));
-		cl.def("push_back", (void (std::deque<int>::*)(const int &)) &std::deque<int, std::allocator<int> >::push_back, "C++: std::deque<int, std::allocator<int> >::push_back(const int &) --> void", pybind11::arg("__x"));
-		cl.def("pop_front", (void (std::deque<int>::*)()) &std::deque<int, std::allocator<int> >::pop_front, "C++: std::deque<int, std::allocator<int> >::pop_front() --> void");
-		cl.def("pop_back", (void (std::deque<int>::*)()) &std::deque<int, std::allocator<int> >::pop_back, "C++: std::deque<int, std::allocator<int> >::pop_back() --> void");
-		cl.def("swap", (void (std::deque<int>::*)(class std::deque<int, class std::allocator<int> > &)) &std::deque<int, std::allocator<int> >::swap, "C++: std::deque<int, std::allocator<int> >::swap(class std::deque<int, class std::allocator<int> > &) --> void", pybind11::arg("__x"));
-		cl.def("clear", (void (std::deque<int>::*)()) &std::deque<int, std::allocator<int> >::clear, "C++: std::deque<int, std::allocator<int> >::clear() --> void");
+		cl.def("assign", (class std::deque<int, class std::allocator<int> > & (std::deque<int>::*)(const class std::deque<int, class std::allocator<int> > &)) &std::deque<int>::operator=, "C++: std::deque<int>::operator=(const class std::deque<int, class std::allocator<int> > &) --> class std::deque<int, class std::allocator<int> > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("assign", (void (std::deque<int>::*)(unsigned long, const int &)) &std::deque<int>::assign, "C++: std::deque<int>::assign(unsigned long, const int &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
+		cl.def("get_allocator", (class std::allocator<int> (std::deque<int>::*)() const) &std::deque<int>::get_allocator, "C++: std::deque<int>::get_allocator() const --> class std::allocator<int>");
+		cl.def("size", (unsigned long (std::deque<int>::*)() const) &std::deque<int>::size, "C++: std::deque<int>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::deque<int>::*)() const) &std::deque<int>::max_size, "C++: std::deque<int>::max_size() const --> unsigned long");
+		cl.def("resize", (void (std::deque<int>::*)(unsigned long)) &std::deque<int>::resize, "C++: std::deque<int>::resize(unsigned long) --> void", pybind11::arg("__new_size"));
+		cl.def("resize", (void (std::deque<int>::*)(unsigned long, const int &)) &std::deque<int>::resize, "C++: std::deque<int>::resize(unsigned long, const int &) --> void", pybind11::arg("__new_size"), pybind11::arg("__x"));
+		cl.def("shrink_to_fit", (void (std::deque<int>::*)()) &std::deque<int>::shrink_to_fit, "C++: std::deque<int>::shrink_to_fit() --> void");
+		cl.def("empty", (bool (std::deque<int>::*)() const) &std::deque<int>::empty, "C++: std::deque<int>::empty() const --> bool");
+		cl.def("__getitem__", (int & (std::deque<int>::*)(unsigned long)) &std::deque<int>::operator[], "C++: std::deque<int>::operator[](unsigned long) --> int &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("at", (int & (std::deque<int>::*)(unsigned long)) &std::deque<int>::at, "C++: std::deque<int>::at(unsigned long) --> int &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("front", (int & (std::deque<int>::*)()) &std::deque<int>::front, "C++: std::deque<int>::front() --> int &", pybind11::return_value_policy::automatic);
+		cl.def("back", (int & (std::deque<int>::*)()) &std::deque<int>::back, "C++: std::deque<int>::back() --> int &", pybind11::return_value_policy::automatic);
+		cl.def("push_front", (void (std::deque<int>::*)(const int &)) &std::deque<int>::push_front, "C++: std::deque<int>::push_front(const int &) --> void", pybind11::arg("__x"));
+		cl.def("push_back", (void (std::deque<int>::*)(const int &)) &std::deque<int>::push_back, "C++: std::deque<int>::push_back(const int &) --> void", pybind11::arg("__x"));
+		cl.def("pop_front", (void (std::deque<int>::*)()) &std::deque<int>::pop_front, "C++: std::deque<int>::pop_front() --> void");
+		cl.def("pop_back", (void (std::deque<int>::*)()) &std::deque<int>::pop_back, "C++: std::deque<int>::pop_back() --> void");
+		cl.def("swap", (void (std::deque<int>::*)(class std::deque<int, class std::allocator<int> > &)) &std::deque<int>::swap, "C++: std::deque<int>::swap(class std::deque<int, class std::allocator<int> > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::deque<int>::*)()) &std::deque<int>::clear, "C++: std::deque<int>::clear() --> void");
 	}
 	{ // std::vector file:bits/stl_vector.h line:210
 		pybind11::class_<std::vector<double>, std::shared_ptr<std::vector<double>>> cl(M("std"), "vector_double_t", "");
@@ -115,33 +123,197 @@ void bind_std_stl_deque(std::function< pybind11::module &(std::string const &nam
 		cl.def( pybind11::init( [](std::vector<double> const &o){ return new std::vector<double>(o); } ) );
 		cl.def( pybind11::init<const class std::vector<double, class std::allocator<double> > &, const class std::allocator<double> &>(), pybind11::arg("__x"), pybind11::arg("__a") );
 
-		cl.def("assign", (class std::vector<double, class std::allocator<double> > & (std::vector<double>::*)(const class std::vector<double, class std::allocator<double> > &)) &std::vector<double, std::allocator<double> >::operator=, "C++: std::vector<double, std::allocator<double> >::operator=(const class std::vector<double, class std::allocator<double> > &) --> class std::vector<double, class std::allocator<double> > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
-		cl.def("assign", (void (std::vector<double>::*)(unsigned long, const double &)) &std::vector<double, std::allocator<double> >::assign, "C++: std::vector<double, std::allocator<double> >::assign(unsigned long, const double &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
-		cl.def("begin", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)()) &std::vector<double, std::allocator<double> >::begin, "C++: std::vector<double, std::allocator<double> >::begin() --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >");
-		cl.def("end", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)()) &std::vector<double, std::allocator<double> >::end, "C++: std::vector<double, std::allocator<double> >::end() --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >");
-		cl.def("cbegin", (class __gnu_cxx::__normal_iterator<const double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)() const) &std::vector<double, std::allocator<double> >::cbegin, "C++: std::vector<double, std::allocator<double> >::cbegin() const --> class __gnu_cxx::__normal_iterator<const double *, class std::vector<double, class std::allocator<double> > >");
-		cl.def("cend", (class __gnu_cxx::__normal_iterator<const double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)() const) &std::vector<double, std::allocator<double> >::cend, "C++: std::vector<double, std::allocator<double> >::cend() const --> class __gnu_cxx::__normal_iterator<const double *, class std::vector<double, class std::allocator<double> > >");
-		cl.def("size", (unsigned long (std::vector<double>::*)() const) &std::vector<double, std::allocator<double> >::size, "C++: std::vector<double, std::allocator<double> >::size() const --> unsigned long");
-		cl.def("max_size", (unsigned long (std::vector<double>::*)() const) &std::vector<double, std::allocator<double> >::max_size, "C++: std::vector<double, std::allocator<double> >::max_size() const --> unsigned long");
-		cl.def("resize", (void (std::vector<double>::*)(unsigned long)) &std::vector<double, std::allocator<double> >::resize, "C++: std::vector<double, std::allocator<double> >::resize(unsigned long) --> void", pybind11::arg("__new_size"));
-		cl.def("resize", (void (std::vector<double>::*)(unsigned long, const double &)) &std::vector<double, std::allocator<double> >::resize, "C++: std::vector<double, std::allocator<double> >::resize(unsigned long, const double &) --> void", pybind11::arg("__new_size"), pybind11::arg("__x"));
-		cl.def("shrink_to_fit", (void (std::vector<double>::*)()) &std::vector<double, std::allocator<double> >::shrink_to_fit, "C++: std::vector<double, std::allocator<double> >::shrink_to_fit() --> void");
-		cl.def("capacity", (unsigned long (std::vector<double>::*)() const) &std::vector<double, std::allocator<double> >::capacity, "C++: std::vector<double, std::allocator<double> >::capacity() const --> unsigned long");
-		cl.def("empty", (bool (std::vector<double>::*)() const) &std::vector<double, std::allocator<double> >::empty, "C++: std::vector<double, std::allocator<double> >::empty() const --> bool");
-		cl.def("reserve", (void (std::vector<double>::*)(unsigned long)) &std::vector<double, std::allocator<double> >::reserve, "C++: std::vector<double, std::allocator<double> >::reserve(unsigned long) --> void", pybind11::arg("__n"));
-		cl.def("__getitem__", (double & (std::vector<double>::*)(unsigned long)) &std::vector<double, std::allocator<double> >::operator[], "C++: std::vector<double, std::allocator<double> >::operator[](unsigned long) --> double &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
-		cl.def("at", (double & (std::vector<double>::*)(unsigned long)) &std::vector<double, std::allocator<double> >::at, "C++: std::vector<double, std::allocator<double> >::at(unsigned long) --> double &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
-		cl.def("front", (double & (std::vector<double>::*)()) &std::vector<double, std::allocator<double> >::front, "C++: std::vector<double, std::allocator<double> >::front() --> double &", pybind11::return_value_policy::automatic);
-		cl.def("back", (double & (std::vector<double>::*)()) &std::vector<double, std::allocator<double> >::back, "C++: std::vector<double, std::allocator<double> >::back() --> double &", pybind11::return_value_policy::automatic);
-		cl.def("data", (double * (std::vector<double>::*)()) &std::vector<double, std::allocator<double> >::data, "C++: std::vector<double, std::allocator<double> >::data() --> double *", pybind11::return_value_policy::automatic);
-		cl.def("push_back", (void (std::vector<double>::*)(const double &)) &std::vector<double, std::allocator<double> >::push_back, "C++: std::vector<double, std::allocator<double> >::push_back(const double &) --> void", pybind11::arg("__x"));
-		cl.def("pop_back", (void (std::vector<double>::*)()) &std::vector<double, std::allocator<double> >::pop_back, "C++: std::vector<double, std::allocator<double> >::pop_back() --> void");
-		cl.def("insert", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, const double &)) &std::vector<double, std::allocator<double> >::insert, "C++: std::vector<double, std::allocator<double> >::insert(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, const double &) --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >", pybind11::arg("__position"), pybind11::arg("__x"));
-		cl.def("insert", (void (std::vector<double>::*)(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, unsigned long, const double &)) &std::vector<double, std::allocator<double> >::insert, "C++: std::vector<double, std::allocator<double> >::insert(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, unsigned long, const double &) --> void", pybind11::arg("__position"), pybind11::arg("__n"), pybind11::arg("__x"));
-		cl.def("erase", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >)) &std::vector<double, std::allocator<double> >::erase, "C++: std::vector<double, std::allocator<double> >::erase(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >) --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >", pybind11::arg("__position"));
-		cl.def("erase", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >)) &std::vector<double, std::allocator<double> >::erase, "C++: std::vector<double, std::allocator<double> >::erase(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >) --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >", pybind11::arg("__first"), pybind11::arg("__last"));
-		cl.def("swap", (void (std::vector<double>::*)(class std::vector<double, class std::allocator<double> > &)) &std::vector<double, std::allocator<double> >::swap, "C++: std::vector<double, std::allocator<double> >::swap(class std::vector<double, class std::allocator<double> > &) --> void", pybind11::arg("__x"));
-		cl.def("clear", (void (std::vector<double>::*)()) &std::vector<double, std::allocator<double> >::clear, "C++: std::vector<double, std::allocator<double> >::clear() --> void");
+		cl.def("assign", (class std::vector<double, class std::allocator<double> > & (std::vector<double>::*)(const class std::vector<double, class std::allocator<double> > &)) &std::vector<double>::operator=, "C++: std::vector<double>::operator=(const class std::vector<double, class std::allocator<double> > &) --> class std::vector<double, class std::allocator<double> > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("assign", (void (std::vector<double>::*)(unsigned long, const double &)) &std::vector<double>::assign, "C++: std::vector<double>::assign(unsigned long, const double &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
+		cl.def("begin", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)()) &std::vector<double>::begin, "C++: std::vector<double>::begin() --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >");
+		cl.def("end", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)()) &std::vector<double>::end, "C++: std::vector<double>::end() --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >");
+		cl.def("cbegin", (class __gnu_cxx::__normal_iterator<const double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)() const) &std::vector<double>::cbegin, "C++: std::vector<double>::cbegin() const --> class __gnu_cxx::__normal_iterator<const double *, class std::vector<double, class std::allocator<double> > >");
+		cl.def("cend", (class __gnu_cxx::__normal_iterator<const double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)() const) &std::vector<double>::cend, "C++: std::vector<double>::cend() const --> class __gnu_cxx::__normal_iterator<const double *, class std::vector<double, class std::allocator<double> > >");
+		cl.def("size", (unsigned long (std::vector<double>::*)() const) &std::vector<double>::size, "C++: std::vector<double>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::vector<double>::*)() const) &std::vector<double>::max_size, "C++: std::vector<double>::max_size() const --> unsigned long");
+		cl.def("resize", (void (std::vector<double>::*)(unsigned long)) &std::vector<double>::resize, "C++: std::vector<double>::resize(unsigned long) --> void", pybind11::arg("__new_size"));
+		cl.def("resize", (void (std::vector<double>::*)(unsigned long, const double &)) &std::vector<double>::resize, "C++: std::vector<double>::resize(unsigned long, const double &) --> void", pybind11::arg("__new_size"), pybind11::arg("__x"));
+		cl.def("shrink_to_fit", (void (std::vector<double>::*)()) &std::vector<double>::shrink_to_fit, "C++: std::vector<double>::shrink_to_fit() --> void");
+		cl.def("capacity", (unsigned long (std::vector<double>::*)() const) &std::vector<double>::capacity, "C++: std::vector<double>::capacity() const --> unsigned long");
+		cl.def("empty", (bool (std::vector<double>::*)() const) &std::vector<double>::empty, "C++: std::vector<double>::empty() const --> bool");
+		cl.def("reserve", (void (std::vector<double>::*)(unsigned long)) &std::vector<double>::reserve, "C++: std::vector<double>::reserve(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("__getitem__", (double & (std::vector<double>::*)(unsigned long)) &std::vector<double>::operator[], "C++: std::vector<double>::operator[](unsigned long) --> double &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("at", (double & (std::vector<double>::*)(unsigned long)) &std::vector<double>::at, "C++: std::vector<double>::at(unsigned long) --> double &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("front", (double & (std::vector<double>::*)()) &std::vector<double>::front, "C++: std::vector<double>::front() --> double &", pybind11::return_value_policy::automatic);
+		cl.def("back", (double & (std::vector<double>::*)()) &std::vector<double>::back, "C++: std::vector<double>::back() --> double &", pybind11::return_value_policy::automatic);
+		cl.def("data", (double * (std::vector<double>::*)()) &std::vector<double>::data, "C++: std::vector<double>::data() --> double *", pybind11::return_value_policy::automatic);
+		cl.def("push_back", (void (std::vector<double>::*)(const double &)) &std::vector<double>::push_back, "C++: std::vector<double>::push_back(const double &) --> void", pybind11::arg("__x"));
+		cl.def("pop_back", (void (std::vector<double>::*)()) &std::vector<double>::pop_back, "C++: std::vector<double>::pop_back() --> void");
+		cl.def("insert", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, const double &)) &std::vector<double>::insert, "C++: std::vector<double>::insert(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, const double &) --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >", pybind11::arg("__position"), pybind11::arg("__x"));
+		cl.def("insert", (void (std::vector<double>::*)(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, unsigned long, const double &)) &std::vector<double>::insert, "C++: std::vector<double>::insert(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, unsigned long, const double &) --> void", pybind11::arg("__position"), pybind11::arg("__n"), pybind11::arg("__x"));
+		cl.def("erase", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >)) &std::vector<double>::erase, "C++: std::vector<double>::erase(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >) --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >", pybind11::arg("__position"));
+		cl.def("erase", (class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > > (std::vector<double>::*)(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >)) &std::vector<double>::erase, "C++: std::vector<double>::erase(class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >, class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >) --> class __gnu_cxx::__normal_iterator<double *, class std::vector<double, class std::allocator<double> > >", pybind11::arg("__first"), pybind11::arg("__last"));
+		cl.def("swap", (void (std::vector<double>::*)(class std::vector<double, class std::allocator<double> > &)) &std::vector<double>::swap, "C++: std::vector<double>::swap(class std::vector<double, class std::allocator<double> > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::vector<double>::*)()) &std::vector<double>::clear, "C++: std::vector<double>::clear() --> void");
+	}
+	{ // std::vector file:bits/stl_vector.h line:210
+		pybind11::class_<std::vector<std::vector<double>>, std::shared_ptr<std::vector<std::vector<double>>>> cl(M("std"), "vector_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::vector<std::vector<double>>(); } ) );
+		cl.def( pybind11::init<const class std::allocator<class std::vector<double, class std::allocator<double> > > &>(), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](unsigned long const & a0){ return new std::vector<std::vector<double>>(a0); } ), "doc" , pybind11::arg("__n"));
+		cl.def( pybind11::init<unsigned long, const class std::allocator<class std::vector<double, class std::allocator<double> > > &>(), pybind11::arg("__n"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](unsigned long const & a0, const class std::vector<double, class std::allocator<double> > & a1){ return new std::vector<std::vector<double>>(a0, a1); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__value"));
+		cl.def( pybind11::init<unsigned long, const class std::vector<double, class std::allocator<double> > &, const class std::allocator<class std::vector<double, class std::allocator<double> > > &>(), pybind11::arg("__n"), pybind11::arg("__value"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::vector<std::vector<double>> const &o){ return new std::vector<std::vector<double>>(o); } ) );
+		cl.def( pybind11::init<const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &, const class std::allocator<class std::vector<double, class std::allocator<double> > > &>(), pybind11::arg("__x"), pybind11::arg("__a") );
+
+		cl.def("assign", (class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > & (std::vector<std::vector<double>>::*)(const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &)) &std::vector<std::vector<double>>::operator=, "C++: std::vector<std::vector<double>>::operator=(const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) --> class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("assign", (void (std::vector<std::vector<double>>::*)(unsigned long, const class std::vector<double, class std::allocator<double> > &)) &std::vector<std::vector<double>>::assign, "C++: std::vector<std::vector<double>>::assign(unsigned long, const class std::vector<double, class std::allocator<double> > &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
+		cl.def("begin", (class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > (std::vector<std::vector<double>>::*)()) &std::vector<std::vector<double>>::begin, "C++: std::vector<std::vector<double>>::begin() --> class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >");
+		cl.def("end", (class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > (std::vector<std::vector<double>>::*)()) &std::vector<std::vector<double>>::end, "C++: std::vector<std::vector<double>>::end() --> class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >");
+		cl.def("cbegin", (class __gnu_cxx::__normal_iterator<const class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > (std::vector<std::vector<double>>::*)() const) &std::vector<std::vector<double>>::cbegin, "C++: std::vector<std::vector<double>>::cbegin() const --> class __gnu_cxx::__normal_iterator<const class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >");
+		cl.def("cend", (class __gnu_cxx::__normal_iterator<const class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > (std::vector<std::vector<double>>::*)() const) &std::vector<std::vector<double>>::cend, "C++: std::vector<std::vector<double>>::cend() const --> class __gnu_cxx::__normal_iterator<const class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >");
+		cl.def("size", (unsigned long (std::vector<std::vector<double>>::*)() const) &std::vector<std::vector<double>>::size, "C++: std::vector<std::vector<double>>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::vector<std::vector<double>>::*)() const) &std::vector<std::vector<double>>::max_size, "C++: std::vector<std::vector<double>>::max_size() const --> unsigned long");
+		cl.def("resize", (void (std::vector<std::vector<double>>::*)(unsigned long)) &std::vector<std::vector<double>>::resize, "C++: std::vector<std::vector<double>>::resize(unsigned long) --> void", pybind11::arg("__new_size"));
+		cl.def("resize", (void (std::vector<std::vector<double>>::*)(unsigned long, const class std::vector<double, class std::allocator<double> > &)) &std::vector<std::vector<double>>::resize, "C++: std::vector<std::vector<double>>::resize(unsigned long, const class std::vector<double, class std::allocator<double> > &) --> void", pybind11::arg("__new_size"), pybind11::arg("__x"));
+		cl.def("shrink_to_fit", (void (std::vector<std::vector<double>>::*)()) &std::vector<std::vector<double>>::shrink_to_fit, "C++: std::vector<std::vector<double>>::shrink_to_fit() --> void");
+		cl.def("capacity", (unsigned long (std::vector<std::vector<double>>::*)() const) &std::vector<std::vector<double>>::capacity, "C++: std::vector<std::vector<double>>::capacity() const --> unsigned long");
+		cl.def("empty", (bool (std::vector<std::vector<double>>::*)() const) &std::vector<std::vector<double>>::empty, "C++: std::vector<std::vector<double>>::empty() const --> bool");
+		cl.def("reserve", (void (std::vector<std::vector<double>>::*)(unsigned long)) &std::vector<std::vector<double>>::reserve, "C++: std::vector<std::vector<double>>::reserve(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("__getitem__", (class std::vector<double, class std::allocator<double> > & (std::vector<std::vector<double>>::*)(unsigned long)) &std::vector<std::vector<double>>::operator[], "C++: std::vector<std::vector<double>>::operator[](unsigned long) --> class std::vector<double, class std::allocator<double> > &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("at", (class std::vector<double, class std::allocator<double> > & (std::vector<std::vector<double>>::*)(unsigned long)) &std::vector<std::vector<double>>::at, "C++: std::vector<std::vector<double>>::at(unsigned long) --> class std::vector<double, class std::allocator<double> > &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("front", (class std::vector<double, class std::allocator<double> > & (std::vector<std::vector<double>>::*)()) &std::vector<std::vector<double>>::front, "C++: std::vector<std::vector<double>>::front() --> class std::vector<double, class std::allocator<double> > &", pybind11::return_value_policy::automatic);
+		cl.def("back", (class std::vector<double, class std::allocator<double> > & (std::vector<std::vector<double>>::*)()) &std::vector<std::vector<double>>::back, "C++: std::vector<std::vector<double>>::back() --> class std::vector<double, class std::allocator<double> > &", pybind11::return_value_policy::automatic);
+		cl.def("data", (class std::vector<double, class std::allocator<double> > * (std::vector<std::vector<double>>::*)()) &std::vector<std::vector<double>>::data, "C++: std::vector<std::vector<double>>::data() --> class std::vector<double, class std::allocator<double> > *", pybind11::return_value_policy::automatic);
+		cl.def("push_back", (void (std::vector<std::vector<double>>::*)(const class std::vector<double, class std::allocator<double> > &)) &std::vector<std::vector<double>>::push_back, "C++: std::vector<std::vector<double>>::push_back(const class std::vector<double, class std::allocator<double> > &) --> void", pybind11::arg("__x"));
+		cl.def("pop_back", (void (std::vector<std::vector<double>>::*)()) &std::vector<std::vector<double>>::pop_back, "C++: std::vector<std::vector<double>>::pop_back() --> void");
+		cl.def("insert", (class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > (std::vector<std::vector<double>>::*)(class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >, const class std::vector<double, class std::allocator<double> > &)) &std::vector<std::vector<double>>::insert, "C++: std::vector<std::vector<double>>::insert(class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >, const class std::vector<double, class std::allocator<double> > &) --> class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >", pybind11::arg("__position"), pybind11::arg("__x"));
+		cl.def("insert", (void (std::vector<std::vector<double>>::*)(class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >, unsigned long, const class std::vector<double, class std::allocator<double> > &)) &std::vector<std::vector<double>>::insert, "C++: std::vector<std::vector<double>>::insert(class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >, unsigned long, const class std::vector<double, class std::allocator<double> > &) --> void", pybind11::arg("__position"), pybind11::arg("__n"), pybind11::arg("__x"));
+		cl.def("erase", (class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > (std::vector<std::vector<double>>::*)(class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >)) &std::vector<std::vector<double>>::erase, "C++: std::vector<std::vector<double>>::erase(class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >) --> class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >", pybind11::arg("__position"));
+		cl.def("erase", (class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > (std::vector<std::vector<double>>::*)(class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >, class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >)) &std::vector<std::vector<double>>::erase, "C++: std::vector<std::vector<double>>::erase(class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >, class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >) --> class __gnu_cxx::__normal_iterator<class std::vector<double, class std::allocator<double> > *, class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > >", pybind11::arg("__first"), pybind11::arg("__last"));
+		cl.def("swap", (void (std::vector<std::vector<double>>::*)(class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &)) &std::vector<std::vector<double>>::swap, "C++: std::vector<std::vector<double>>::swap(class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::vector<std::vector<double>>::*)()) &std::vector<std::vector<double>>::clear, "C++: std::vector<std::vector<double>>::clear() --> void");
+	}
+}
+
+
+// File: std/stl_vector.cpp
+#include <iterator> // __gnu_cxx::__normal_iterator
+#include <memory> // std::allocator
+#include <sstream> // __str__
+#include <vector> // std::vector
+
+#include <pybind11/pybind11.h>
+#include <functional>
+#include <string>
+
+#ifndef BINDER_PYBIND11_TYPE_CASTER
+	#define BINDER_PYBIND11_TYPE_CASTER
+	PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
+	PYBIND11_DECLARE_HOLDER_TYPE(T, T*)
+	PYBIND11_MAKE_OPAQUE(std::shared_ptr<void>)
+#endif
+
+void bind_std_stl_vector(std::function< pybind11::module &(std::string const &namespace_) > &M)
+{
+	{ // std::vector file:bits/stl_vector.h line:210
+		pybind11::class_<std::vector<std::vector<std::vector<double>>>, std::shared_ptr<std::vector<std::vector<std::vector<double>>>>> cl(M("std"), "vector_std_vector_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::vector<std::vector<std::vector<double>>>(); } ) );
+		cl.def( pybind11::init<const class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > &>(), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](unsigned long const & a0){ return new std::vector<std::vector<std::vector<double>>>(a0); } ), "doc" , pybind11::arg("__n"));
+		cl.def( pybind11::init<unsigned long, const class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > &>(), pybind11::arg("__n"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](unsigned long const & a0, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > & a1){ return new std::vector<std::vector<std::vector<double>>>(a0, a1); } ), "doc" , pybind11::arg("__n"), pybind11::arg("__value"));
+		cl.def( pybind11::init<unsigned long, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &, const class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > &>(), pybind11::arg("__n"), pybind11::arg("__value"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::vector<std::vector<std::vector<double>>> const &o){ return new std::vector<std::vector<std::vector<double>>>(o); } ) );
+		cl.def( pybind11::init<const class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > &, const class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > &>(), pybind11::arg("__x"), pybind11::arg("__a") );
+
+		cl.def("assign", (class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > & (std::vector<std::vector<std::vector<double>>>::*)(const class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > &)) &std::vector<std::vector<std::vector<double>>>::operator=, "C++: std::vector<std::vector<std::vector<double>>>::operator=(const class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > &) --> class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("assign", (void (std::vector<std::vector<std::vector<double>>>::*)(unsigned long, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &)) &std::vector<std::vector<std::vector<double>>>::assign, "C++: std::vector<std::vector<std::vector<double>>>::assign(unsigned long, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
+		cl.def("begin", (class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > (std::vector<std::vector<std::vector<double>>>::*)()) &std::vector<std::vector<std::vector<double>>>::begin, "C++: std::vector<std::vector<std::vector<double>>>::begin() --> class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >");
+		cl.def("end", (class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > (std::vector<std::vector<std::vector<double>>>::*)()) &std::vector<std::vector<std::vector<double>>>::end, "C++: std::vector<std::vector<std::vector<double>>>::end() --> class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >");
+		cl.def("cbegin", (class __gnu_cxx::__normal_iterator<const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > (std::vector<std::vector<std::vector<double>>>::*)() const) &std::vector<std::vector<std::vector<double>>>::cbegin, "C++: std::vector<std::vector<std::vector<double>>>::cbegin() const --> class __gnu_cxx::__normal_iterator<const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >");
+		cl.def("cend", (class __gnu_cxx::__normal_iterator<const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > (std::vector<std::vector<std::vector<double>>>::*)() const) &std::vector<std::vector<std::vector<double>>>::cend, "C++: std::vector<std::vector<std::vector<double>>>::cend() const --> class __gnu_cxx::__normal_iterator<const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >");
+		cl.def("size", (unsigned long (std::vector<std::vector<std::vector<double>>>::*)() const) &std::vector<std::vector<std::vector<double>>>::size, "C++: std::vector<std::vector<std::vector<double>>>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::vector<std::vector<std::vector<double>>>::*)() const) &std::vector<std::vector<std::vector<double>>>::max_size, "C++: std::vector<std::vector<std::vector<double>>>::max_size() const --> unsigned long");
+		cl.def("resize", (void (std::vector<std::vector<std::vector<double>>>::*)(unsigned long)) &std::vector<std::vector<std::vector<double>>>::resize, "C++: std::vector<std::vector<std::vector<double>>>::resize(unsigned long) --> void", pybind11::arg("__new_size"));
+		cl.def("resize", (void (std::vector<std::vector<std::vector<double>>>::*)(unsigned long, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &)) &std::vector<std::vector<std::vector<double>>>::resize, "C++: std::vector<std::vector<std::vector<double>>>::resize(unsigned long, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) --> void", pybind11::arg("__new_size"), pybind11::arg("__x"));
+		cl.def("shrink_to_fit", (void (std::vector<std::vector<std::vector<double>>>::*)()) &std::vector<std::vector<std::vector<double>>>::shrink_to_fit, "C++: std::vector<std::vector<std::vector<double>>>::shrink_to_fit() --> void");
+		cl.def("capacity", (unsigned long (std::vector<std::vector<std::vector<double>>>::*)() const) &std::vector<std::vector<std::vector<double>>>::capacity, "C++: std::vector<std::vector<std::vector<double>>>::capacity() const --> unsigned long");
+		cl.def("empty", (bool (std::vector<std::vector<std::vector<double>>>::*)() const) &std::vector<std::vector<std::vector<double>>>::empty, "C++: std::vector<std::vector<std::vector<double>>>::empty() const --> bool");
+		cl.def("reserve", (void (std::vector<std::vector<std::vector<double>>>::*)(unsigned long)) &std::vector<std::vector<std::vector<double>>>::reserve, "C++: std::vector<std::vector<std::vector<double>>>::reserve(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("__getitem__", (class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > & (std::vector<std::vector<std::vector<double>>>::*)(unsigned long)) &std::vector<std::vector<std::vector<double>>>::operator[], "C++: std::vector<std::vector<std::vector<double>>>::operator[](unsigned long) --> class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("at", (class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > & (std::vector<std::vector<std::vector<double>>>::*)(unsigned long)) &std::vector<std::vector<std::vector<double>>>::at, "C++: std::vector<std::vector<std::vector<double>>>::at(unsigned long) --> class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("front", (class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > & (std::vector<std::vector<std::vector<double>>>::*)()) &std::vector<std::vector<std::vector<double>>>::front, "C++: std::vector<std::vector<std::vector<double>>>::front() --> class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &", pybind11::return_value_policy::automatic);
+		cl.def("back", (class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > & (std::vector<std::vector<std::vector<double>>>::*)()) &std::vector<std::vector<std::vector<double>>>::back, "C++: std::vector<std::vector<std::vector<double>>>::back() --> class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &", pybind11::return_value_policy::automatic);
+		cl.def("data", (class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > * (std::vector<std::vector<std::vector<double>>>::*)()) &std::vector<std::vector<std::vector<double>>>::data, "C++: std::vector<std::vector<std::vector<double>>>::data() --> class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *", pybind11::return_value_policy::automatic);
+		cl.def("push_back", (void (std::vector<std::vector<std::vector<double>>>::*)(const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &)) &std::vector<std::vector<std::vector<double>>>::push_back, "C++: std::vector<std::vector<std::vector<double>>>::push_back(const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) --> void", pybind11::arg("__x"));
+		cl.def("pop_back", (void (std::vector<std::vector<std::vector<double>>>::*)()) &std::vector<std::vector<std::vector<double>>>::pop_back, "C++: std::vector<std::vector<std::vector<double>>>::pop_back() --> void");
+		cl.def("insert", (class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > (std::vector<std::vector<std::vector<double>>>::*)(class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &)) &std::vector<std::vector<std::vector<double>>>::insert, "C++: std::vector<std::vector<std::vector<double>>>::insert(class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) --> class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >", pybind11::arg("__position"), pybind11::arg("__x"));
+		cl.def("insert", (void (std::vector<std::vector<std::vector<double>>>::*)(class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >, unsigned long, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &)) &std::vector<std::vector<std::vector<double>>>::insert, "C++: std::vector<std::vector<std::vector<double>>>::insert(class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >, unsigned long, const class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > &) --> void", pybind11::arg("__position"), pybind11::arg("__n"), pybind11::arg("__x"));
+		cl.def("erase", (class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > (std::vector<std::vector<std::vector<double>>>::*)(class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >)) &std::vector<std::vector<std::vector<double>>>::erase, "C++: std::vector<std::vector<std::vector<double>>>::erase(class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >) --> class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >", pybind11::arg("__position"));
+		cl.def("erase", (class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > (std::vector<std::vector<std::vector<double>>>::*)(class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >, class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >)) &std::vector<std::vector<std::vector<double>>>::erase, "C++: std::vector<std::vector<std::vector<double>>>::erase(class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >, class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >) --> class __gnu_cxx::__normal_iterator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > *, class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > >", pybind11::arg("__first"), pybind11::arg("__last"));
+		cl.def("swap", (void (std::vector<std::vector<std::vector<double>>>::*)(class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > &)) &std::vector<std::vector<std::vector<double>>>::swap, "C++: std::vector<std::vector<std::vector<double>>>::swap(class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::vector<std::vector<std::vector<double>>>::*)()) &std::vector<std::vector<std::vector<double>>>::clear, "C++: std::vector<std::vector<std::vector<double>>>::clear() --> void");
+	}
+}
+
+
+// File: std/stl_vector_1.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
+#include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
+#include <memory> // std::allocator
+#include <sstream> // __str__
+#include <vector> // std::vector
+
+#include <pybind11/pybind11.h>
+#include <functional>
+#include <string>
+
+#ifndef BINDER_PYBIND11_TYPE_CASTER
+	#define BINDER_PYBIND11_TYPE_CASTER
+	PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
+	PYBIND11_DECLARE_HOLDER_TYPE(T, T*)
+	PYBIND11_MAKE_OPAQUE(std::shared_ptr<void>)
+#endif
+
+void bind_std_stl_vector_1(std::function< pybind11::module &(std::string const &namespace_) > &M)
+{
+	{ // std::vector file:bits/stl_vector.h line:210
+		pybind11::class_<std::vector<std::list<std::forward_list<std::deque<double>>>>, std::shared_ptr<std::vector<std::list<std::forward_list<std::deque<double>>>>>> cl(M("std"), "vector_std_list_std_forward_list_std_deque_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::vector<std::list<std::forward_list<std::deque<double>>>>(); } ) );
+		cl.def( pybind11::init<const class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > &>(), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](unsigned long const & a0){ return new std::vector<std::list<std::forward_list<std::deque<double>>>>(a0); } ), "doc" , pybind11::arg("__n"));
+		cl.def( pybind11::init<unsigned long, const class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > &>(), pybind11::arg("__n"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::vector<std::list<std::forward_list<std::deque<double>>>> const &o){ return new std::vector<std::list<std::forward_list<std::deque<double>>>>(o); } ) );
+		cl.def( pybind11::init<const class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > &, const class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > &>(), pybind11::arg("__x"), pybind11::arg("__a") );
+
+		cl.def("assign", (class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > & (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)(const class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > &)) &std::vector<std::list<std::forward_list<std::deque<double>>>>::operator=, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::operator=(const class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > &) --> class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("begin", (class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > > (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)()) &std::vector<std::list<std::forward_list<std::deque<double>>>>::begin, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::begin() --> class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >");
+		cl.def("end", (class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > > (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)()) &std::vector<std::list<std::forward_list<std::deque<double>>>>::end, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::end() --> class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >");
+		cl.def("cbegin", (class __gnu_cxx::__normal_iterator<const class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > > (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)() const) &std::vector<std::list<std::forward_list<std::deque<double>>>>::cbegin, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::cbegin() const --> class __gnu_cxx::__normal_iterator<const class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >");
+		cl.def("cend", (class __gnu_cxx::__normal_iterator<const class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > > (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)() const) &std::vector<std::list<std::forward_list<std::deque<double>>>>::cend, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::cend() const --> class __gnu_cxx::__normal_iterator<const class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >");
+		cl.def("size", (unsigned long (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)() const) &std::vector<std::list<std::forward_list<std::deque<double>>>>::size, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)() const) &std::vector<std::list<std::forward_list<std::deque<double>>>>::max_size, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::max_size() const --> unsigned long");
+		cl.def("resize", (void (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)(unsigned long)) &std::vector<std::list<std::forward_list<std::deque<double>>>>::resize, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::resize(unsigned long) --> void", pybind11::arg("__new_size"));
+		cl.def("shrink_to_fit", (void (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)()) &std::vector<std::list<std::forward_list<std::deque<double>>>>::shrink_to_fit, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::shrink_to_fit() --> void");
+		cl.def("capacity", (unsigned long (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)() const) &std::vector<std::list<std::forward_list<std::deque<double>>>>::capacity, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::capacity() const --> unsigned long");
+		cl.def("empty", (bool (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)() const) &std::vector<std::list<std::forward_list<std::deque<double>>>>::empty, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::empty() const --> bool");
+		cl.def("reserve", (void (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)(unsigned long)) &std::vector<std::list<std::forward_list<std::deque<double>>>>::reserve, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::reserve(unsigned long) --> void", pybind11::arg("__n"));
+		cl.def("__getitem__", (class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > & (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)(unsigned long)) &std::vector<std::list<std::forward_list<std::deque<double>>>>::operator[], "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::operator[](unsigned long) --> class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("at", (class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > & (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)(unsigned long)) &std::vector<std::list<std::forward_list<std::deque<double>>>>::at, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::at(unsigned long) --> class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__n"));
+		cl.def("front", (class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > & (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)()) &std::vector<std::list<std::forward_list<std::deque<double>>>>::front, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::front() --> class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > &", pybind11::return_value_policy::automatic);
+		cl.def("back", (class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > & (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)()) &std::vector<std::list<std::forward_list<std::deque<double>>>>::back, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::back() --> class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > &", pybind11::return_value_policy::automatic);
+		cl.def("pop_back", (void (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)()) &std::vector<std::list<std::forward_list<std::deque<double>>>>::pop_back, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::pop_back() --> void");
+		cl.def("erase", (class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > > (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)(class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >)) &std::vector<std::list<std::forward_list<std::deque<double>>>>::erase, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::erase(class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >) --> class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >", pybind11::arg("__position"));
+		cl.def("erase", (class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > > (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)(class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >, class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >)) &std::vector<std::list<std::forward_list<std::deque<double>>>>::erase, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::erase(class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >, class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >) --> class __gnu_cxx::__normal_iterator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > *, class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > >", pybind11::arg("__first"), pybind11::arg("__last"));
+		cl.def("swap", (void (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)(class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > &)) &std::vector<std::list<std::forward_list<std::deque<double>>>>::swap, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::swap(class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::vector<std::list<std::forward_list<std::deque<double>>>>::*)()) &std::vector<std::list<std::forward_list<std::deque<double>>>>::clear, "C++: std::vector<std::list<std::forward_list<std::deque<double>>>>::clear() --> void");
 	}
 }
 
@@ -178,23 +350,23 @@ void bind_std_forward_list(std::function< pybind11::module &(std::string const &
 		cl.def( pybind11::init<unsigned long, const float &, const class std::allocator<float> &>(), pybind11::arg("__n"), pybind11::arg("__value"), pybind11::arg("__al") );
 
 		cl.def( pybind11::init( [](std::forward_list<float> const &o){ return new std::forward_list<float>(o); } ) );
-		cl.def("assign", (class std::forward_list<float, class std::allocator<float> > & (std::forward_list<float>::*)(const class std::forward_list<float, class std::allocator<float> > &)) &std::forward_list<float, std::allocator<float> >::operator=, "C++: std::forward_list<float, std::allocator<float> >::operator=(const class std::forward_list<float, class std::allocator<float> > &) --> class std::forward_list<float, class std::allocator<float> > &", pybind11::return_value_policy::automatic, pybind11::arg("__list"));
-		cl.def("assign", (void (std::forward_list<float>::*)(unsigned long, const float &)) &std::forward_list<float, std::allocator<float> >::assign, "C++: std::forward_list<float, std::allocator<float> >::assign(unsigned long, const float &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
-		cl.def("get_allocator", (class std::allocator<float> (std::forward_list<float>::*)() const) &std::forward_list<float, std::allocator<float> >::get_allocator, "C++: std::forward_list<float, std::allocator<float> >::get_allocator() const --> class std::allocator<float>");
-		cl.def("empty", (bool (std::forward_list<float>::*)() const) &std::forward_list<float, std::allocator<float> >::empty, "C++: std::forward_list<float, std::allocator<float> >::empty() const --> bool");
-		cl.def("max_size", (unsigned long (std::forward_list<float>::*)() const) &std::forward_list<float, std::allocator<float> >::max_size, "C++: std::forward_list<float, std::allocator<float> >::max_size() const --> unsigned long");
-		cl.def("front", (float & (std::forward_list<float>::*)()) &std::forward_list<float, std::allocator<float> >::front, "C++: std::forward_list<float, std::allocator<float> >::front() --> float &", pybind11::return_value_policy::automatic);
-		cl.def("push_front", (void (std::forward_list<float>::*)(const float &)) &std::forward_list<float, std::allocator<float> >::push_front, "C++: std::forward_list<float, std::allocator<float> >::push_front(const float &) --> void", pybind11::arg("__val"));
-		cl.def("pop_front", (void (std::forward_list<float>::*)()) &std::forward_list<float, std::allocator<float> >::pop_front, "C++: std::forward_list<float, std::allocator<float> >::pop_front() --> void");
-		cl.def("swap", (void (std::forward_list<float>::*)(class std::forward_list<float, class std::allocator<float> > &)) &std::forward_list<float, std::allocator<float> >::swap, "C++: std::forward_list<float, std::allocator<float> >::swap(class std::forward_list<float, class std::allocator<float> > &) --> void", pybind11::arg("__list"));
-		cl.def("resize", (void (std::forward_list<float>::*)(unsigned long)) &std::forward_list<float, std::allocator<float> >::resize, "C++: std::forward_list<float, std::allocator<float> >::resize(unsigned long) --> void", pybind11::arg("__sz"));
-		cl.def("resize", (void (std::forward_list<float>::*)(unsigned long, const float &)) &std::forward_list<float, std::allocator<float> >::resize, "C++: std::forward_list<float, std::allocator<float> >::resize(unsigned long, const float &) --> void", pybind11::arg("__sz"), pybind11::arg("__val"));
-		cl.def("clear", (void (std::forward_list<float>::*)()) &std::forward_list<float, std::allocator<float> >::clear, "C++: std::forward_list<float, std::allocator<float> >::clear() --> void");
-		cl.def("remove", (void (std::forward_list<float>::*)(const float &)) &std::forward_list<float, std::allocator<float> >::remove, "C++: std::forward_list<float, std::allocator<float> >::remove(const float &) --> void", pybind11::arg("__val"));
-		cl.def("unique", (void (std::forward_list<float>::*)()) &std::forward_list<float, std::allocator<float> >::unique, "C++: std::forward_list<float, std::allocator<float> >::unique() --> void");
-		cl.def("merge", (void (std::forward_list<float>::*)(class std::forward_list<float, class std::allocator<float> > &)) &std::forward_list<float, std::allocator<float> >::merge, "C++: std::forward_list<float, std::allocator<float> >::merge(class std::forward_list<float, class std::allocator<float> > &) --> void", pybind11::arg("__list"));
-		cl.def("sort", (void (std::forward_list<float>::*)()) &std::forward_list<float, std::allocator<float> >::sort, "C++: std::forward_list<float, std::allocator<float> >::sort() --> void");
-		cl.def("reverse", (void (std::forward_list<float>::*)()) &std::forward_list<float, std::allocator<float> >::reverse, "C++: std::forward_list<float, std::allocator<float> >::reverse() --> void");
+		cl.def("assign", (class std::forward_list<float, class std::allocator<float> > & (std::forward_list<float>::*)(const class std::forward_list<float, class std::allocator<float> > &)) &std::forward_list<float>::operator=, "C++: std::forward_list<float>::operator=(const class std::forward_list<float, class std::allocator<float> > &) --> class std::forward_list<float, class std::allocator<float> > &", pybind11::return_value_policy::automatic, pybind11::arg("__list"));
+		cl.def("assign", (void (std::forward_list<float>::*)(unsigned long, const float &)) &std::forward_list<float>::assign, "C++: std::forward_list<float>::assign(unsigned long, const float &) --> void", pybind11::arg("__n"), pybind11::arg("__val"));
+		cl.def("get_allocator", (class std::allocator<float> (std::forward_list<float>::*)() const) &std::forward_list<float>::get_allocator, "C++: std::forward_list<float>::get_allocator() const --> class std::allocator<float>");
+		cl.def("empty", (bool (std::forward_list<float>::*)() const) &std::forward_list<float>::empty, "C++: std::forward_list<float>::empty() const --> bool");
+		cl.def("max_size", (unsigned long (std::forward_list<float>::*)() const) &std::forward_list<float>::max_size, "C++: std::forward_list<float>::max_size() const --> unsigned long");
+		cl.def("front", (float & (std::forward_list<float>::*)()) &std::forward_list<float>::front, "C++: std::forward_list<float>::front() --> float &", pybind11::return_value_policy::automatic);
+		cl.def("push_front", (void (std::forward_list<float>::*)(const float &)) &std::forward_list<float>::push_front, "C++: std::forward_list<float>::push_front(const float &) --> void", pybind11::arg("__val"));
+		cl.def("pop_front", (void (std::forward_list<float>::*)()) &std::forward_list<float>::pop_front, "C++: std::forward_list<float>::pop_front() --> void");
+		cl.def("swap", (void (std::forward_list<float>::*)(class std::forward_list<float, class std::allocator<float> > &)) &std::forward_list<float>::swap, "C++: std::forward_list<float>::swap(class std::forward_list<float, class std::allocator<float> > &) --> void", pybind11::arg("__list"));
+		cl.def("resize", (void (std::forward_list<float>::*)(unsigned long)) &std::forward_list<float>::resize, "C++: std::forward_list<float>::resize(unsigned long) --> void", pybind11::arg("__sz"));
+		cl.def("resize", (void (std::forward_list<float>::*)(unsigned long, const float &)) &std::forward_list<float>::resize, "C++: std::forward_list<float>::resize(unsigned long, const float &) --> void", pybind11::arg("__sz"), pybind11::arg("__val"));
+		cl.def("clear", (void (std::forward_list<float>::*)()) &std::forward_list<float>::clear, "C++: std::forward_list<float>::clear() --> void");
+		cl.def("remove", (void (std::forward_list<float>::*)(const float &)) &std::forward_list<float>::remove, "C++: std::forward_list<float>::remove(const float &) --> void", pybind11::arg("__val"));
+		cl.def("unique", (void (std::forward_list<float>::*)()) &std::forward_list<float>::unique, "C++: std::forward_list<float>::unique() --> void");
+		cl.def("merge", (void (std::forward_list<float>::*)(class std::forward_list<float, class std::allocator<float> > &)) &std::forward_list<float>::merge, "C++: std::forward_list<float>::merge(class std::forward_list<float, class std::allocator<float> > &) --> void", pybind11::arg("__list"));
+		cl.def("sort", (void (std::forward_list<float>::*)()) &std::forward_list<float>::sort, "C++: std::forward_list<float>::sort() --> void");
+		cl.def("reverse", (void (std::forward_list<float>::*)()) &std::forward_list<float>::reverse, "C++: std::forward_list<float>::reverse() --> void");
 	}
 }
 
@@ -221,18 +393,27 @@ void bind_std_forward_list(std::function< pybind11::module &(std::string const &
 
 void bind_T42_stl_names(std::function< pybind11::module &(std::string const &namespace_) > &M)
 {
-	// foo(class std::list<double, class std::allocator<double> >) file:T42.stl.names.hpp line:26
+	// foo(class std::list<double, class std::allocator<double> >) file:T42.stl.names.hpp line:25
 	M("").def("foo", (void (*)(class std::list<double, class std::allocator<double> >)) &foo, "C++: foo(class std::list<double, class std::allocator<double> >) --> void", pybind11::arg(""));
 
-	// foo(class std::forward_list<float, class std::allocator<float> >) file:T42.stl.names.hpp line:27
+	// foo(class std::forward_list<float, class std::allocator<float> >) file:T42.stl.names.hpp line:26
 	M("").def("foo", (void (*)(class std::forward_list<float, class std::allocator<float> >)) &foo, "C++: foo(class std::forward_list<float, class std::allocator<float> >) --> void", pybind11::arg(""));
 
-	// foo(class std::vector<double, class std::allocator<double> >) file:T42.stl.names.hpp line:28
+	// foo(class std::vector<double, class std::allocator<double> >) file:T42.stl.names.hpp line:27
 	M("").def("foo", (void (*)(class std::vector<double, class std::allocator<double> >)) &foo, "C++: foo(class std::vector<double, class std::allocator<double> >) --> void", pybind11::arg(""));
 
-	// foo(class std::deque<int, class std::allocator<int> >) file:T42.stl.names.hpp line:29
+	// foo(class std::deque<int, class std::allocator<int> >) file:T42.stl.names.hpp line:28
 	M("").def("foo", (void (*)(class std::deque<int, class std::allocator<int> >)) &foo, "C++: foo(class std::deque<int, class std::allocator<int> >) --> void", pybind11::arg(""));
 
+	// foo(class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >) file:T42.stl.names.hpp line:30
+	M("").def("foo", (void (*)(class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >)) &foo, "C++: foo(class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >) --> void", pybind11::arg(""));
+
+	// foo(class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >) file:T42.stl.names.hpp line:31
+	M("").def("foo", (void (*)(class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >)) &foo, "C++: foo(class std::vector<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::vector<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >) --> void", pybind11::arg(""));
+
+	// foo(class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > >) file:T42.stl.names.hpp line:33
+	M("").def("foo", (void (*)(class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > >)) &foo, "C++: foo(class std::vector<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > >, class std::allocator<class std::forward_list<class std::deque<double, class std::allocator<double> >, class std::allocator<class std::deque<double, class std::allocator<double> > > > > > > >) --> void", pybind11::arg(""));
+
 }
 
 
@@ -248,6 +429,8 @@ typedef std::function< pybind11::module & (std::string const &) > ModuleGetter;
 
 void bind_std_stl_list(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_std_stl_deque(std::function< pybind11::module &(std::string const &namespace_) > &M);
+void bind_std_stl_vector(std::function< pybind11::module &(std::string const &namespace_) > &M);
+void bind_std_stl_vector_1(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_std_forward_list(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_T42_stl_names(std::function< pybind11::module &(std::string const &namespace_) > &M);
 
@@ -273,6 +456,8 @@ PYBIND11_MODULE(T42_stl_names, root_module) {
 
 	bind_std_stl_list(M);
 	bind_std_stl_deque(M);
+	bind_std_stl_vector(M);
+	bind_std_stl_vector_1(M);
 	bind_std_forward_list(M);
 	bind_T42_stl_names(M);
 
@@ -282,6 +467,8 @@ PYBIND11_MODULE(T42_stl_names, root_module) {
 // T42_stl_names.cpp
 // std/stl_list.cpp
 // std/stl_deque.cpp
+// std/stl_vector.cpp
+// std/stl_vector_1.cpp
 // std/forward_list.cpp
 // T42_stl_names.cpp
 
diff --git a/test/T42.stl.names.set.hpp b/test/T42.stl.names.set.hpp
index 95b2691b..c6ad9de8 100644
--- a/test/T42.stl.names.set.hpp
+++ b/test/T42.stl.names.set.hpp
@@ -11,7 +11,7 @@
 /// @author Sergey Lyskov
 
 /// The multimap/multiset classes are tested in the binder/test/T43.stl.names.multi.hpp to avoid
-/// problems with different ordering of multiset/set and multimap/map bindings 
+/// problems with different ordering of multiset/set and multimap/map bindings
 /// in the generated files on different platforms.
 #ifndef _INCLUDED_T42_stl_names_set_hpp_
 #define _INCLUDED_T42_stl_names_set_hpp_
@@ -20,8 +20,15 @@
 #include <set>
 #include <unordered_set>
 
+#include <list>
+#include <vector>
+#include <deque>
+#include <vector>
+#include <forward_list>
+
 void foo(std::set<float> ) {}
 void foo(std::unordered_set<float> ) {}
 
+void foo(std::set<std::list< std::forward_list< std::deque< std::vector<double> > > > > ) {}
 
 #endif // _INCLUDED_T42_stl_names_set_hpp_
diff --git a/test/T42.stl.names.set.ref b/test/T42.stl.names.set.ref
index c2e2c7f6..fd37ce3b 100644
--- a/test/T42.stl.names.set.ref
+++ b/test/T42.stl.names.set.ref
@@ -1,13 +1,18 @@
 // File: std/stl_function.cpp
+#include <deque> // std::deque
 #include <exception> // std::bad_exception
 #include <exception> // std::exception
 #include <exception> // std::terminate
 #include <exception> // std::uncaught_exception
 #include <exception> // std::unexpected
+#include <forward_list> // std::forward_list
 #include <functional> // std::binary_function
 #include <functional> // std::equal_to
 #include <functional> // std::less
+#include <list> // std::list
+#include <memory> // std::allocator
 #include <sstream> // __str__
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -38,12 +43,14 @@ void bind_std_stl_function(std::function< pybind11::module &(std::string const &
 
 
 // File: std/functional_hash.cpp
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::_Manager_operation
 #include <functional> // std::bad_function_call
-#include <functional> // std::equal_to
 #include <functional> // std::hash
 #include <functional> // std::less
 #include <iterator> // __gnu_cxx::__normal_iterator
+#include <list> // std::list
 #include <map> // std::_Rb_tree_color
 #include <map> // std::_Rb_tree_const_iterator
 #include <memory> // std::allocator
@@ -63,10 +70,8 @@ void bind_std_stl_function(std::function< pybind11::module &(std::string const &
 #include <string> // std::char_traits
 #include <string> // std::hash
 #include <tuple> // std::tuple
-#include <unordered_map> // std::__detail::_Node_const_iterator
-#include <unordered_map> // std::__detail::_Node_iterator
-#include <unordered_set> // std::unordered_set
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -109,6 +114,49 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 		cl.def("count", (unsigned long (std::set<float>::*)(const float &) const) &std::set<float, std::less<float>, std::allocator<float> >::count, "C++: std::set<float, std::less<float>, std::allocator<float> >::count(const float &) const --> unsigned long", pybind11::arg("__x"));
 		cl.def("equal_range", (struct std::pair<struct std::_Rb_tree_const_iterator<float>, struct std::_Rb_tree_const_iterator<float> > (std::set<float>::*)(const float &)) &std::set<float, std::less<float>, std::allocator<float> >::equal_range, "C++: std::set<float, std::less<float>, std::allocator<float> >::equal_range(const float &) --> struct std::pair<struct std::_Rb_tree_const_iterator<float>, struct std::_Rb_tree_const_iterator<float> >", pybind11::arg("__x"));
 	}
+	{ // std::set file:bits/stl_set.h line:90
+		pybind11::class_<std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>, std::shared_ptr<std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>>> cl(M("std"), "set_std_list_std_forward_list_std_deque_std_vector_double_std_less_std_list_std_forward_list_std_deque_std_vector_double_std_allocator_std_list_std_forward_list_std_deque_std_vector_double_t", "");
+		cl.def( pybind11::init( [](){ return new std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>(); } ) );
+		cl.def( pybind11::init( [](const struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > & a0){ return new std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>(a0); } ), "doc" , pybind11::arg("__comp"));
+		cl.def( pybind11::init<const struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > &, const class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > &>(), pybind11::arg("__comp"), pybind11::arg("__a") );
+
+		cl.def( pybind11::init( [](std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >> const &o){ return new std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>(o); } ) );
+		cl.def("assign", (class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > & (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)(const class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &)) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::operator=, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::operator=(const class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &) --> class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &", pybind11::return_value_policy::automatic, pybind11::arg("__x"));
+		cl.def("key_comp", (struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)() const) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::key_comp, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::key_comp() const --> struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >");
+		cl.def("value_comp", (struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)() const) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::value_comp, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::value_comp() const --> struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >");
+		cl.def("get_allocator", (class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)() const) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::get_allocator, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::get_allocator() const --> class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >");
+		cl.def("empty", (bool (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)() const) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::empty, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::empty() const --> bool");
+		cl.def("size", (unsigned long (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)() const) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::size, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::size() const --> unsigned long");
+		cl.def("max_size", (unsigned long (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)() const) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::max_size, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::max_size() const --> unsigned long");
+		cl.def("swap", (void (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)(class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &)) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::swap, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::swap(class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > > &) --> void", pybind11::arg("__x"));
+		cl.def("clear", (void (std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>,std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >,std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> >>::*)()) &std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::clear, "C++: std::set<std::list<std::forward_list<std::deque<std::vector<double>>>>, std::less<std::list<std::forward_list<std::deque<std::vector<double>>>> >, std::allocator<std::list<std::forward_list<std::deque<std::vector<double>>>> > >::clear() --> void");
+	}
+}
+
+
+// File: std/unordered_set.cpp
+#include <functional> // std::equal_to
+#include <functional> // std::hash
+#include <memory> // std::allocator
+#include <sstream> // __str__
+#include <unordered_map> // std::__detail::_Node_const_iterator
+#include <unordered_map> // std::__detail::_Node_iterator
+#include <unordered_set> // std::unordered_set
+#include <utility> // std::pair
+
+#include <pybind11/pybind11.h>
+#include <functional>
+#include <string>
+
+#ifndef BINDER_PYBIND11_TYPE_CASTER
+	#define BINDER_PYBIND11_TYPE_CASTER
+	PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)
+	PYBIND11_DECLARE_HOLDER_TYPE(T, T*)
+	PYBIND11_MAKE_OPAQUE(std::shared_ptr<void>)
+#endif
+
+void bind_std_unordered_set(std::function< pybind11::module &(std::string const &namespace_) > &M)
+{
 	{ // std::unordered_set file:bits/unordered_set.h line:93
 		pybind11::class_<std::unordered_set<float>, std::shared_ptr<std::unordered_set<float>>> cl(M("std"), "unordered_set_float_t", "");
 		cl.def( pybind11::init( [](){ return new std::unordered_set<float>(); } ), "doc" );
@@ -146,9 +194,12 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 
 // File: T42_stl_names_set.cpp
 #include <T42.stl.names.set.hpp> // foo
+#include <deque> // std::deque
+#include <forward_list> // std::forward_list
 #include <functional> // std::equal_to
 #include <functional> // std::hash
 #include <functional> // std::less
+#include <list> // std::list
 #include <map> // std::_Rb_tree_const_iterator
 #include <memory> // std::allocator
 #include <set> // std::set
@@ -156,6 +207,7 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 #include <unordered_map> // std::__detail::_Node_iterator
 #include <unordered_set> // std::unordered_set
 #include <utility> // std::pair
+#include <vector> // std::vector
 
 #include <pybind11/pybind11.h>
 #include <functional>
@@ -170,12 +222,15 @@ void bind_std_functional_hash(std::function< pybind11::module &(std::string cons
 
 void bind_T42_stl_names_set(std::function< pybind11::module &(std::string const &namespace_) > &M)
 {
-	// foo(class std::set<float, struct std::less<float>, class std::allocator<float> >) file:T42.stl.names.set.hpp line:23
+	// foo(class std::set<float, struct std::less<float>, class std::allocator<float> >) file:T42.stl.names.set.hpp line:29
 	M("").def("foo", (void (*)(class std::set<float, struct std::less<float>, class std::allocator<float> >)) &foo, "C++: foo(class std::set<float, struct std::less<float>, class std::allocator<float> >) --> void", pybind11::arg(""));
 
-	// foo(class std::unordered_set<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) file:T42.stl.names.set.hpp line:24
+	// foo(class std::unordered_set<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) file:T42.stl.names.set.hpp line:30
 	M("").def("foo", (void (*)(class std::unordered_set<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >)) &foo, "C++: foo(class std::unordered_set<float, struct std::hash<float>, struct std::equal_to<float>, class std::allocator<float> >) --> void", pybind11::arg(""));
 
+	// foo(class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >) file:T42.stl.names.set.hpp line:32
+	M("").def("foo", (void (*)(class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >)) &foo, "C++: foo(class std::set<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > >, struct std::less<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > >, class std::allocator<class std::list<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > >, class std::allocator<class std::forward_list<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > >, class std::allocator<class std::deque<class std::vector<double, class std::allocator<double> >, class std::allocator<class std::vector<double, class std::allocator<double> > > > > > > > > >) --> void", pybind11::arg(""));
+
 }
 
 
@@ -191,6 +246,7 @@ typedef std::function< pybind11::module & (std::string const &) > ModuleGetter;
 
 void bind_std_stl_function(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_std_functional_hash(std::function< pybind11::module &(std::string const &namespace_) > &M);
+void bind_std_unordered_set(std::function< pybind11::module &(std::string const &namespace_) > &M);
 void bind_T42_stl_names_set(std::function< pybind11::module &(std::string const &namespace_) > &M);
 
 
@@ -215,6 +271,7 @@ PYBIND11_MODULE(T42_stl_names_set, root_module) {
 
 	bind_std_stl_function(M);
 	bind_std_functional_hash(M);
+	bind_std_unordered_set(M);
 	bind_T42_stl_names_set(M);
 
 }
@@ -223,6 +280,7 @@ PYBIND11_MODULE(T42_stl_names_set, root_module) {
 // T42_stl_names_set.cpp
 // std/stl_function.cpp
 // std/functional_hash.cpp
+// std/unordered_set.cpp
 // T42_stl_names_set.cpp
 
 // Modules list file: TEST/T42_stl_names_set.modules