xrl/ROMol.h

## autocxxgen_ffi.h
// FROM rdkit-autocxx-repro/target/debug/build/rdkit-autocxx-repro-af359ecff0c3ad28/out/autocxx-build-dir/include/autocxxgen_ffi.h
#ifndef __AUTOCXXGEN_H__
#define __AUTOCXXGEN_H__

#include <memory>
#include <string>
#include "cxx.h"
#include <stddef.h>
#ifndef AUTOCXX_NEW_AND_DELETE_PRELUDE
#define AUTOCXX_NEW_AND_DELETE_PRELUDE
// Mechanics to call custom operator new and delete
template <typename T>
auto delete_imp(T *ptr, int) -> decltype((void)T::operator delete(ptr)) {
  T::operator delete(ptr);
}
template <typename T> void delete_imp(T *ptr, long) { ::operator delete(ptr); }
template <typename T> void delete_appropriately(T *obj) {
  // 0 is a better match for the first 'delete_imp' so will match
  // preferentially.
  delete_imp(obj, 0);
}
template <typename T>
auto new_imp(size_t count, int) -> decltype(T::operator new(count)) {
  return T::operator new(count);
}
template <typename T> void *new_imp(size_t count, long) {
  return ::operator new(count);
}
template <typename T> T *new_appropriately() {
  // 0 is a better match for the first 'delete_imp' so will match
  // preferentially.
  return static_cast<T *>(new_imp<T>(sizeof(T), 0));
}
#endif // AUTOCXX_NEW_AND_DELETE_PRELUDE
#include "RDGeneral/RDAny.h"
#include "GraphMol/ROMol.h"

typedef std::reverse_iterator<iterator> std_reverse_iterator_iterator_AutocxxConcrete;
typedef std::reverse_iterator<uint64_t> std_reverse_iterator_uint64_t_AutocxxConcrete;
typedef boost::uniform_real<double> boost_uniform_real_double_AutocxxConcrete;
typedef boost::adjacency_list<boost::no_property> boost_adjacency_list_boost_no_property_AutocxxConcrete;
typedef std::pair<RDKit::ROMol::EDGE_ITER, RDKit::ROMol::EDGE_ITER> std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete;
typedef std::pair<RDKit::ROMol::OEDGE_ITER, RDKit::ROMol::OEDGE_ITER> std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete;
typedef std::pair<RDKit::ROMol::VERTEX_ITER, RDKit::ROMol::VERTEX_ITER> std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete;
typedef std::pair<RDKit::ROMol::ADJ_ITER, RDKit::ROMol::ADJ_ITER> std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete;
typedef std::pair<RDKit::ROMol::CONF_SPTR_LIST_I, RDKit::ROMol::CONF_SPTR_LIST_I> std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete;
typedef int c_int;
typedef unsigned int c_uint;
typedef short c_short;
typedef long long c_longlong;
typedef unsigned short c_ushort;
typedef unsigned long long c_ulonglong;

inline std::unique_ptr<std::string> autocxx_make_string_0x7001b89d03cdd863(::rust::Str str) { return std::make_unique<std::string>(std::string(str)); }
inline RDKit::Utils::LocaleSwitcher* LocaleSwitcher_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::Utils::LocaleSwitcher>();; }
inline void LocaleSwitcher_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Utils::LocaleSwitcher* arg0)  { delete_appropriately<RDKit::Utils::LocaleSwitcher>(arg0);; }
inline void RDKit_Utils_LocaleSwitcher_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Utils::LocaleSwitcher* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::Utils::LocaleSwitcher(); }
inline void LocaleSwitcher_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Utils::LocaleSwitcher* arg0)  { arg0->~LocaleSwitcher(); }
inline RDKit::RDTypeTag::detail::Value* Value_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::RDTypeTag::detail::Value>();; }
inline void Value_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* arg0)  { delete_appropriately<RDKit::RDTypeTag::detail::Value>(arg0);; }
inline void RDKit_RDTypeTag_detail_Value_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(); }
inline void RDKit_RDTypeTag_detail_Value_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, double arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void RDKit_RDTypeTag_detail_Value_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, float arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void RDKit_RDTypeTag_detail_Value_new3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, int arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void RDKit_RDTypeTag_detail_Value_new4_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, unsigned int arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void RDKit_RDTypeTag_detail_Value_new5_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, bool arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void RDKit_RDTypeTag_detail_Value_new6_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, std::string* arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void new7_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, boost::any* arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void new8_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, std::vector<double>* arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void new9_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, std::vector<float>* arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void new12_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, std::vector<std::string>* arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline boost::any* valuePtrCast_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* arg0)  { return RDKit::RDTypeTag::detail::valuePtrCast(std::move(*arg0)); }
inline std::string* valuePtrCast1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* arg0)  { return RDKit::RDTypeTag::detail::valuePtrCast(std::move(*arg0)); }
inline std::vector<double>* valuePtrCast2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* arg0)  { return RDKit::RDTypeTag::detail::valuePtrCast(std::move(*arg0)); }
inline std::vector<float>* valuePtrCast3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* arg0)  { return RDKit::RDTypeTag::detail::valuePtrCast(std::move(*arg0)); }
inline std::vector<std::string>* valuePtrCast6_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* arg0)  { return RDKit::RDTypeTag::detail::valuePtrCast(std::move(*arg0)); }
inline RDKit::RDValue* RDValue_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::RDValue>();; }
inline void RDValue_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { delete_appropriately<RDKit::RDValue>(arg0);; }
inline RDKit::RDAny* RDAny_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::RDAny>();; }
inline void RDAny_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDAny* arg0)  { delete_appropriately<RDKit::RDAny>(arg0);; }
inline RDKit::Dict* Dict_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::Dict>();; }
inline void Dict_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict* arg0)  { delete_appropriately<RDKit::Dict>(arg0);; }
inline RDKit::Dict::Pair* Dict_Pair_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::Dict::Pair>();; }
inline void Dict_Pair_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict::Pair* arg0)  { delete_appropriately<RDKit::Dict::Pair>(arg0);; }
inline RDKit::ltDouble* ltDouble_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::ltDouble>();; }
inline void ltDouble_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ltDouble* arg0)  { delete_appropriately<RDKit::ltDouble>(arg0);; }
inline RDKit::charptr_functor* charptr_functor_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::charptr_functor>();; }
inline void charptr_functor_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::charptr_functor* arg0)  { delete_appropriately<RDKit::charptr_functor>(arg0);; }
inline RDKit::RDProps* RDProps_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::RDProps>();; }
inline void RDProps_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDProps* arg0)  { delete_appropriately<RDKit::RDProps>(arg0);; }
inline const RDKit::RDProps& cast_Atom_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom& arg0)  { return arg0; }
inline RDKit::Atom* Atom_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::Atom>();; }
inline void Atom_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom* arg0)  { delete_appropriately<RDKit::Atom>(arg0);; }
inline const RDKit::RDProps& cast_Bond_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& arg0)  { return arg0; }
inline RDKit::Bond* Bond_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::Bond>();; }
inline void Bond_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond* arg0)  { delete_appropriately<RDKit::Bond>(arg0);; }
inline RDKit::ConformerException* ConformerException_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::ConformerException>();; }
inline void ConformerException_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ConformerException* arg0)  { delete_appropriately<RDKit::ConformerException>(arg0);; }
inline const RDKit::RDProps& cast_Conformer_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Conformer& arg0)  { return arg0; }
inline RDKit::Conformer* Conformer_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::Conformer>();; }
inline void Conformer_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Conformer* arg0)  { delete_appropriately<RDKit::Conformer>(arg0);; }
inline RDKit::SubstanceGroupException* SubstanceGroupException_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::SubstanceGroupException>();; }
inline void SubstanceGroupException_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroupException* arg0)  { delete_appropriately<RDKit::SubstanceGroupException>(arg0);; }
inline const RDKit::RDProps& cast_SubstanceGroup_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::SubstanceGroup& arg0)  { return arg0; }
inline RDKit::SubstanceGroup* SubstanceGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::SubstanceGroup>();; }
inline void SubstanceGroup_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup* arg0)  { delete_appropriately<RDKit::SubstanceGroup>(arg0);; }
inline RDKit::SubstanceGroup::AttachPoint* SubstanceGroup_AttachPoint_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::SubstanceGroup::AttachPoint>();; }
inline void SubstanceGroup_AttachPoint_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::AttachPoint* arg0)  { delete_appropriately<RDKit::SubstanceGroup::AttachPoint>(arg0);; }
inline RDKit::SubstanceGroup::CState* SubstanceGroup_CState_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::SubstanceGroup::CState>();; }
inline void SubstanceGroup_CState_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::CState* arg0)  { delete_appropriately<RDKit::SubstanceGroup::CState>(arg0);; }
inline RDKit::StereoGroup* StereoGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::StereoGroup>();; }
inline void StereoGroup_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::StereoGroup* arg0)  { delete_appropriately<RDKit::StereoGroup>(arg0);; }
inline RDKit::RingInfo* RingInfo_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::RingInfo>();; }
inline void RingInfo_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RingInfo* arg0)  { delete_appropriately<RDKit::RingInfo>(arg0);; }
inline const RDKit::RDProps& cast_ROMol_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ROMol& arg0)  { return arg0; }
inline RDKit::ROMol* ROMol_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDKit::ROMol>();; }
inline void ROMol_free_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol* arg0)  { delete_appropriately<RDKit::ROMol>(arg0);; }
inline void RDKit_RDValue_destroy_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue& autocxx_gen_this)  { autocxx_gen_this.destroy(); }
inline void cleanup_rdvalue_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue& arg0)  { RDKit::RDValue::cleanup_rdvalue(arg0); }
inline void RDKit_RDValue_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::RDValue(); }
inline void RDKit_RDValue_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, double arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, float arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, int arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new4_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, unsigned int arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new5_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, bool arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new6_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, boost::any* arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new7_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, const boost::any& arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new8_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, const std::string& arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new9_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, const std::vector<double>& arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDKit_RDValue_new10_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, const std::vector<float>& arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void new13_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, const std::vector<std::string>& arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline bool rdvalue_is_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_is(std::move(*arg0)); }
inline double rdvalue_cast_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline float rdvalue_cast1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline int rdvalue_cast2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline int8_t rdvalue_cast3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline short rdvalue_cast4_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline long long rdvalue_cast5_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline unsigned int rdvalue_cast6_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline uint8_t rdvalue_cast7_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline unsigned short rdvalue_cast8_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline unsigned long long rdvalue_cast9_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline bool rdvalue_cast10_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return RDKit::rdvalue_cast(std::move(*arg0)); }
inline std::unique_ptr<std::string> rdvalue_cast11_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return std::make_unique<std::string>(RDKit::rdvalue_cast(std::move(*arg0))); }
inline std::unique_ptr<std::vector<double>> rdvalue_cast13_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return std::make_unique<std::vector<double>>(RDKit::rdvalue_cast(std::move(*arg0))); }
inline std::unique_ptr<std::vector<float>> rdvalue_cast15_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return std::make_unique<std::vector<float>>(RDKit::rdvalue_cast(std::move(*arg0))); }
inline std::unique_ptr<std::vector<std::string>> rdvalue_cast17_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { return std::make_unique<std::vector<std::string>>(RDKit::rdvalue_cast(std::move(*arg0))); }
inline void rdvalue_cast23_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0, boost::any* arg1)  { new(arg1) boost::any(RDKit::rdvalue_cast(std::move(*arg0))); }
inline bool rdvalue_tostring_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0, std::string& arg1)  { return RDKit::rdvalue_tostring(std::move(*arg0), arg1); }
inline void RDKit_RDAny_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDAny* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::RDAny(); }
inline void RDKit_RDAny_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDAny* autocxx_gen_this, const RDKit::RDAny& arg1)  { new (autocxx_gen_this) RDKit::RDAny(arg1); }
inline void RDAny_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDAny* arg0)  { arg0->~RDAny(); }
inline void RDKit_Dict_Pair_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict::Pair* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::Dict::Pair(); }
inline void RDKit_Dict_Pair_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict::Pair* autocxx_gen_this, std::unique_ptr<std::string> arg1)  { new (autocxx_gen_this) RDKit::Dict::Pair(std::move(*arg1)); }
inline void RDKit_Dict_Pair_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict::Pair* autocxx_gen_this, std::unique_ptr<std::string> arg1, const RDKit::RDValue& arg2)  { new (autocxx_gen_this) RDKit::Dict::Pair(std::move(*arg1), arg2); }
inline std::unique_ptr<std::vector<std::string>> keys_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Dict& autocxx_gen_this)  { return std::make_unique<std::vector<std::string>>(autocxx_gen_this.keys()); }
inline void RDKit_Dict_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::Dict(); }
inline void RDKit_Dict_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict* autocxx_gen_this, const RDKit::Dict& arg1)  { new (autocxx_gen_this) RDKit::Dict(arg1); }
inline void RDKit_Dict_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict* autocxx_gen_this, RDKit::Dict* arg1)  { new (autocxx_gen_this) RDKit::Dict(std::move(*arg1)); }
inline void Dict_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict* arg0)  { arg0->~Dict(); }
inline void RDKit_ltDouble_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ltDouble* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::ltDouble(); }
inline void RDKit_RDProps_clear_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDProps& autocxx_gen_this)  { autocxx_gen_this.clear(); }
inline std::unique_ptr<std::vector<std::string>> getPropList_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::RDProps& autocxx_gen_this, bool arg1, bool arg2)  { return std::make_unique<std::vector<std::string>>(autocxx_gen_this.getPropList(arg1, arg2)); }
inline void RDKit_RDProps_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDProps* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::RDProps(); }
inline void RDKit_RDProps_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDProps* autocxx_gen_this, const RDKit::RDProps& arg1)  { new (autocxx_gen_this) RDKit::RDProps(arg1); }
inline void RDKit_RDProps_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDProps* autocxx_gen_this, RDKit::RDProps* arg1)  { new (autocxx_gen_this) RDKit::RDProps(std::move(*arg1)); }
inline std::unique_ptr<std::string> getSymbol_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom& autocxx_gen_this)  { return std::make_unique<std::string>(autocxx_gen_this.getSymbol()); }
inline void RDKit_Atom_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::Atom(); }
inline void RDKit_Atom_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom* autocxx_gen_this, unsigned int arg1)  { new (autocxx_gen_this) RDKit::Atom(arg1); }
inline void RDKit_Atom_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom* autocxx_gen_this, const std::string& arg1)  { new (autocxx_gen_this) RDKit::Atom(arg1); }
inline void RDKit_Atom_new3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom* autocxx_gen_this, const RDKit::Atom& arg1)  { new (autocxx_gen_this) RDKit::Atom(arg1); }
inline void RDKit_Atom_new4_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom* autocxx_gen_this, RDKit::Atom* arg1)  { new (autocxx_gen_this) RDKit::Atom(std::move(*arg1)); }
inline void Atom_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom* arg0)  { arg0->~Atom(); }
inline RDKit::Atom* copy_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom& autocxx_gen_this)  { return autocxx_gen_this.copy(); }
inline bool hasQuery_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom& autocxx_gen_this)  { return autocxx_gen_this.hasQuery(); }
inline std::unique_ptr<std::string> getQueryType_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom& autocxx_gen_this)  { return std::make_unique<std::string>(autocxx_gen_this.getQueryType()); }
inline void setQuery_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom& autocxx_gen_this, uint8_t* arg1)  { autocxx_gen_this.setQuery(arg1); }
inline uint8_t* getQuery_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom& autocxx_gen_this)  { return autocxx_gen_this.getQuery(); }
inline void expandQuery_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Atom& autocxx_gen_this, uint8_t* arg1, Queries::CompositeQueryType arg2, bool arg3)  { autocxx_gen_this.expandQuery(arg1, arg2, arg3); }
inline bool Match_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom& autocxx_gen_this, const RDKit::Atom* arg1)  { return autocxx_gen_this.Match(arg1); }
inline std::unique_ptr<std::string> getAtomAlias_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom* arg0)  { return std::make_unique<std::string>(RDKit::getAtomAlias(arg0)); }
inline std::unique_ptr<std::string> getAtomValue_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom* arg0)  { return std::make_unique<std::string>(RDKit::getAtomValue(arg0)); }
inline std::unique_ptr<std::string> getSupplementalSmilesLabel_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Atom* arg0)  { return std::make_unique<std::string>(RDKit::getSupplementalSmilesLabel(arg0)); }
inline void RDKit_Bond_setIsAromatic_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond& autocxx_gen_this, bool arg1)  { autocxx_gen_this.setIsAromatic(arg1); }
inline bool RDKit_Bond_getIsAromatic_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& autocxx_gen_this)  { return autocxx_gen_this.getIsAromatic(); }
inline bool RDKit_Bond_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& autocxx_gen_this)  { return autocxx_gen_this.hasOwningMol(); }
inline void RDKit_Bond_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond& autocxx_gen_this, RDKit::ROMol* arg1)  { autocxx_gen_this.setOwningMol(arg1); }
inline void RDKit_Bond_setOwningMol1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond& autocxx_gen_this, RDKit::ROMol& arg1)  { autocxx_gen_this.setOwningMol(arg1); }
inline unsigned int RDKit_Bond_getIdx_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& autocxx_gen_this)  { return autocxx_gen_this.getIdx(); }
inline void RDKit_Bond_setIdx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond& autocxx_gen_this, unsigned int arg1)  { autocxx_gen_this.setIdx(arg1); }
inline void RDKit_Bond_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond& autocxx_gen_this, bool arg1)  { autocxx_gen_this.updatePropertyCache(arg1); }
inline void RDKit_Bond_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::Bond(); }
inline void RDKit_Bond_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond* autocxx_gen_this, RDKit::Bond::BondType arg1)  { new (autocxx_gen_this) RDKit::Bond(arg1); }
inline void RDKit_Bond_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond* autocxx_gen_this, const RDKit::Bond& arg1)  { new (autocxx_gen_this) RDKit::Bond(arg1); }
inline void RDKit_Bond_new3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond* autocxx_gen_this, RDKit::Bond* arg1)  { new (autocxx_gen_this) RDKit::Bond(std::move(*arg1)); }
inline void Bond_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond* arg0)  { arg0->~Bond(); }
inline RDKit::Bond* RDKit_Bond_copy_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& autocxx_gen_this)  { return autocxx_gen_this.copy(); }
inline double getValenceContrib_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& autocxx_gen_this, const RDKit::Atom* arg1)  { return autocxx_gen_this.getValenceContrib(arg1); }
inline bool RDKit_Bond_hasQuery_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& autocxx_gen_this)  { return autocxx_gen_this.hasQuery(); }
inline void RDKit_Bond_setQuery_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond& autocxx_gen_this, uint8_t* arg1)  { autocxx_gen_this.setQuery(arg1); }
inline uint8_t* RDKit_Bond_getQuery_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& autocxx_gen_this)  { return autocxx_gen_this.getQuery(); }
inline void RDKit_Bond_expandQuery_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Bond& autocxx_gen_this, uint8_t* arg1, Queries::CompositeQueryType arg2, bool arg3)  { autocxx_gen_this.expandQuery(arg1, arg2, arg3); }
inline bool RDKit_Bond_Match_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Bond& autocxx_gen_this, const RDKit::Bond* arg1)  { return autocxx_gen_this.Match(arg1); }
inline std::unique_ptr<std::string> augmentTagName_autocxx_wrapper_0x7001b89d03cdd863(const std::string& arg0)  { return std::make_unique<std::string>(RDKit::augmentTagName(arg0)); }
inline void RDKit_ConformerException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ConformerException* autocxx_gen_this, const char* arg1)  { new (autocxx_gen_this) RDKit::ConformerException(arg1); }
inline void RDKit_ConformerException_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ConformerException* autocxx_gen_this, std::unique_ptr<std::string> arg1)  { new (autocxx_gen_this) RDKit::ConformerException(std::move(*arg1)); }
inline const char* RDKit_ConformerException_what_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ConformerException& autocxx_gen_this)  { return autocxx_gen_this.what(); }
inline void ConformerException_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ConformerException* arg0)  { arg0->~ConformerException(); }
inline bool RDKit_Conformer_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::Conformer& autocxx_gen_this)  { return autocxx_gen_this.hasOwningMol(); }
inline void RDKit_Conformer_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Conformer* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::Conformer(); }
inline void RDKit_Conformer_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Conformer* autocxx_gen_this, unsigned int arg1)  { new (autocxx_gen_this) RDKit::Conformer(arg1); }
inline void RDKit_Conformer_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Conformer* autocxx_gen_this, const RDKit::Conformer& arg1)  { new (autocxx_gen_this) RDKit::Conformer(arg1); }
inline void RDKit_Conformer_new3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Conformer* autocxx_gen_this, RDKit::Conformer* arg1)  { new (autocxx_gen_this) RDKit::Conformer(std::move(*arg1)); }
inline void Conformer_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Conformer* arg0)  { arg0->~Conformer(); }
inline void RDKit_SubstanceGroupException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroupException* autocxx_gen_this, const char* arg1)  { new (autocxx_gen_this) RDKit::SubstanceGroupException(arg1); }
inline void RDKit_SubstanceGroupException_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroupException* autocxx_gen_this, const std::string& arg1)  { new (autocxx_gen_this) RDKit::SubstanceGroupException(arg1); }
inline bool RDKit_SubstanceGroup_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::SubstanceGroup& autocxx_gen_this)  { return autocxx_gen_this.hasOwningMol(); }
inline RDKit::SubstanceGroup::BondType RDKit_SubstanceGroup_getBondType_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::SubstanceGroup& autocxx_gen_this, unsigned int arg1)  { return autocxx_gen_this.getBondType(arg1); }
inline void RDKit_SubstanceGroup_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup& autocxx_gen_this, RDKit::ROMol* arg1)  { autocxx_gen_this.setOwningMol(arg1); }
inline void RDKit_SubstanceGroup_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup* autocxx_gen_this, RDKit::ROMol* arg1, const std::string& arg2)  { new (autocxx_gen_this) RDKit::SubstanceGroup(arg1, arg2); }
inline void RDKit_SubstanceGroup_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup* autocxx_gen_this, const RDKit::SubstanceGroup& arg1)  { new (autocxx_gen_this) RDKit::SubstanceGroup(arg1); }
inline void RDKit_SubstanceGroup_new3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup* autocxx_gen_this, RDKit::SubstanceGroup* arg1)  { new (autocxx_gen_this) RDKit::SubstanceGroup(std::move(*arg1)); }
inline void SubstanceGroup_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup* arg0)  { arg0->~SubstanceGroup(); }
inline unsigned int addSubstanceGroup_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol& arg0, RDKit::SubstanceGroup* arg1)  { return RDKit::addSubstanceGroup(arg0, std::move(*arg1)); }
inline void RDKit_StereoGroup_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::StereoGroup* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::StereoGroup(); }
inline void RDKit_StereoGroup_new3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::StereoGroup* autocxx_gen_this, const RDKit::StereoGroup& arg1)  { new (autocxx_gen_this) RDKit::StereoGroup(arg1); }
inline void RDKit_StereoGroup_new4_autocxx_wrapper_0x7001b89d03cdd863(RDKit::StereoGroup* autocxx_gen_this, RDKit::StereoGroup* arg1)  { new (autocxx_gen_this) RDKit::StereoGroup(std::move(*arg1)); }
inline void RDKit_RingInfo_reset_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RingInfo& autocxx_gen_this)  { autocxx_gen_this.reset(); }
inline void RDKit_RingInfo_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RingInfo* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::RingInfo(); }
inline void RDKit_RingInfo_new1_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RingInfo* autocxx_gen_this, const RDKit::RingInfo& arg1)  { new (autocxx_gen_this) RDKit::RingInfo(arg1); }
inline void RDKit_RingInfo_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RingInfo* autocxx_gen_this, RDKit::RingInfo* arg1)  { new (autocxx_gen_this) RDKit::RingInfo(std::move(*arg1)); }
inline unsigned int RDKit_ROMol_getNumAtoms_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ROMol& autocxx_gen_this)  { return autocxx_gen_this.getNumAtoms(); }
inline std::unique_ptr<std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> getAtomNeighbors_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ROMol& autocxx_gen_this, const RDKit::Atom* arg1)  { return std::make_unique<std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>(autocxx_gen_this.getAtomNeighbors(arg1)); }
inline std::unique_ptr<std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> getAtomBonds_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ROMol& autocxx_gen_this, const RDKit::Atom* arg1)  { return std::make_unique<std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>(autocxx_gen_this.getAtomBonds(arg1)); }
inline std::unique_ptr<std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> getVertices_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol& autocxx_gen_this)  { return std::make_unique<std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>(autocxx_gen_this.getVertices()); }
inline std::unique_ptr<std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> getEdges_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol& autocxx_gen_this)  { return std::make_unique<std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>(autocxx_gen_this.getEdges()); }
inline std::unique_ptr<std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> getVertices1_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ROMol& autocxx_gen_this)  { return std::make_unique<std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>(autocxx_gen_this.getVertices()); }
inline std::unique_ptr<std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> getEdges1_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ROMol& autocxx_gen_this)  { return std::make_unique<std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>(autocxx_gen_this.getEdges()); }
inline void RDKit_ROMol_clearComputedProps_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ROMol& autocxx_gen_this, bool arg1)  { autocxx_gen_this.clearComputedProps(arg1); }
inline void RDKit_ROMol_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol& autocxx_gen_this, bool arg1)  { autocxx_gen_this.updatePropertyCache(arg1); }
inline bool RDKit_ROMol_needsUpdatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863(const RDKit::ROMol& autocxx_gen_this)  { return autocxx_gen_this.needsUpdatePropertyCache(); }
inline void setStereoGroups_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol& autocxx_gen_this, std::vector<RDKit::StereoGroup>* arg1)  { autocxx_gen_this.setStereoGroups(std::move(*arg1)); }
inline void RDKit_ROMol_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::ROMol(); }
inline void RDKit_ROMol_new2_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol* autocxx_gen_this, const std::string& arg1)  { new (autocxx_gen_this) RDKit::ROMol(arg1); }
inline void RDKit_ROMol_new3_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol* autocxx_gen_this, const std::string& arg1, unsigned int arg2)  { new (autocxx_gen_this) RDKit::ROMol(arg1, arg2); }
inline void RDKit_ROMol_new4_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol* autocxx_gen_this, RDKit::ROMol* arg1)  { new (autocxx_gen_this) RDKit::ROMol(std::move(*arg1)); }
inline void ROMol_destructor_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ROMol* arg0)  { arg0->~ROMol(); }
inline void RDKit_Utils_LocaleSwitcher_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Utils::LocaleSwitcher* autocxx_gen_this, const RDKit::Utils::LocaleSwitcher& arg1)  { new (autocxx_gen_this) RDKit::Utils::LocaleSwitcher(arg1); }
inline void RDKit_RDTypeTag_detail_Value_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, RDKit::RDTypeTag::detail::Value* arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(std::move(*arg1)); }
inline void RDKit_RDTypeTag_detail_Value_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* autocxx_gen_this, const RDKit::RDTypeTag::detail::Value& arg1)  { new (autocxx_gen_this) RDKit::RDTypeTag::detail::Value(arg1); }
inline void Value_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDTypeTag::detail::Value* arg0)  { arg0->~Value(); }
inline void RDKit_RDValue_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, RDKit::RDValue* arg1)  { new (autocxx_gen_this) RDKit::RDValue(std::move(*arg1)); }
inline void RDKit_RDValue_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* autocxx_gen_this, const RDKit::RDValue& arg1)  { new (autocxx_gen_this) RDKit::RDValue(arg1); }
inline void RDValue_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDValue* arg0)  { arg0->~RDValue(); }
inline void Dict_Pair_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict::Pair* autocxx_gen_this, RDKit::Dict::Pair* arg1)  { new (autocxx_gen_this) RDKit::Dict::Pair(std::move(*arg1)); }
inline void Dict_Pair_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict::Pair* autocxx_gen_this, const RDKit::Dict::Pair& arg1)  { new (autocxx_gen_this) RDKit::Dict::Pair(arg1); }
inline void Dict_Pair_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::Dict::Pair* arg0)  { arg0->~Pair(); }
inline void RDKit_ltDouble_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ltDouble* autocxx_gen_this, RDKit::ltDouble* arg1)  { new (autocxx_gen_this) RDKit::ltDouble(std::move(*arg1)); }
inline void RDKit_ltDouble_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ltDouble* autocxx_gen_this, const RDKit::ltDouble& arg1)  { new (autocxx_gen_this) RDKit::ltDouble(arg1); }
inline void ltDouble_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ltDouble* arg0)  { arg0->~ltDouble(); }
inline void RDKit_charptr_functor_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::charptr_functor* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::charptr_functor(); }
inline void RDKit_charptr_functor_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::charptr_functor* autocxx_gen_this, RDKit::charptr_functor* arg1)  { new (autocxx_gen_this) RDKit::charptr_functor(std::move(*arg1)); }
inline void RDKit_charptr_functor_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::charptr_functor* autocxx_gen_this, const RDKit::charptr_functor& arg1)  { new (autocxx_gen_this) RDKit::charptr_functor(arg1); }
inline void charptr_functor_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::charptr_functor* arg0)  { arg0->~charptr_functor(); }
inline void RDProps_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RDProps* arg0)  { arg0->~RDProps(); }
inline void RDKit_ConformerException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::ConformerException* autocxx_gen_this, const RDKit::ConformerException& arg1)  { new (autocxx_gen_this) RDKit::ConformerException(arg1); }
inline void RDKit_SubstanceGroupException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroupException* autocxx_gen_this, const RDKit::SubstanceGroupException& arg1)  { new (autocxx_gen_this) RDKit::SubstanceGroupException(arg1); }
inline void SubstanceGroupException_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroupException* arg0)  { arg0->~SubstanceGroupException(); }
inline void RDKit_SubstanceGroup_AttachPoint_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::AttachPoint* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::SubstanceGroup::AttachPoint(); }
inline void SubstanceGroup_AttachPoint_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::AttachPoint* autocxx_gen_this, RDKit::SubstanceGroup::AttachPoint* arg1)  { new (autocxx_gen_this) RDKit::SubstanceGroup::AttachPoint(std::move(*arg1)); }
inline void SubstanceGroup_AttachPoint_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::AttachPoint* autocxx_gen_this, const RDKit::SubstanceGroup::AttachPoint& arg1)  { new (autocxx_gen_this) RDKit::SubstanceGroup::AttachPoint(arg1); }
inline void SubstanceGroup_AttachPoint_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::AttachPoint* arg0)  { arg0->~AttachPoint(); }
inline void StereoGroup_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::StereoGroup* arg0)  { arg0->~StereoGroup(); }
inline void RingInfo_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::RingInfo* arg0)  { arg0->~RingInfo(); }
inline void RDKit_SubstanceGroup_CState_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::CState* autocxx_gen_this)  { new (autocxx_gen_this) RDKit::SubstanceGroup::CState(); }
inline void SubstanceGroup_CState_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::CState* autocxx_gen_this, const RDKit::SubstanceGroup::CState& arg1)  { new (autocxx_gen_this) RDKit::SubstanceGroup::CState(arg1); }
inline void SubstanceGroup_CState_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(RDKit::SubstanceGroup::CState* arg0)  { arg0->~CState(); }
inline boost::any* any_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<boost::any>();; }
inline void any_free_autocxx_wrapper_0x7001b89d03cdd863(boost::any* arg0)  { delete_appropriately<boost::any>(arg0);; }
inline void boost_any_new1_autocxx_wrapper_0x7001b89d03cdd863(boost::any* autocxx_gen_this, const boost::any& arg1)  { new (autocxx_gen_this) boost::any(arg1); }
inline void boost_any_new2_autocxx_wrapper_0x7001b89d03cdd863(boost::any* autocxx_gen_this, boost::any* arg1)  { new (autocxx_gen_this) boost::any(std::move(*arg1)); }
inline RDGeom::Point3D* Point3D_alloc_autocxx_wrapper_0x7001b89d03cdd863()  { return new_appropriately<RDGeom::Point3D>();; }
inline void Point3D_free_autocxx_wrapper_0x7001b89d03cdd863(RDGeom::Point3D* arg0)  { delete_appropriately<RDGeom::Point3D>(arg0);; }
inline void RDGeom_Point3D_new2_autocxx_wrapper_0x7001b89d03cdd863(RDGeom::Point3D* autocxx_gen_this, const RDGeom::Point3D& arg1)  { new (autocxx_gen_this) RDGeom::Point3D(arg1); }
#endif // __AUTOCXXGEN_H__

## gen0.cxx
// FROM /Users/xlange/code/assaydepot/rdkit-autocxx-repro/target/debug/build/rdkit-autocxx-repro-af359ecff0c3ad28/out/autocxx-build-dir/cxx/gen0.cxx
#include "RDGeneral/RDAny.h"
#include "GraphMol/ROMol.h"
#include "autocxxgen_ffi.h"
#include <array>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <new>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

namespace rust {
inline namespace cxxbridge1 {
// #include "rust/cxx.h"

namespace {
template <typename T>
class impl;
} // namespace

class String;

#ifndef CXXBRIDGE1_RUST_STR
#define CXXBRIDGE1_RUST_STR
class Str final {
public:
  Str() noexcept;
  Str(const String &) noexcept;
  Str(const std::string &);
  Str(const char *);
  Str(const char *, std::size_t);

  Str &operator=(const Str &) &noexcept = default;

  explicit operator std::string() const;

  const char *data() const noexcept;
  std::size_t size() const noexcept;
  std::size_t length() const noexcept;
  bool empty() const noexcept;

  Str(const Str &) noexcept = default;
  ~Str() noexcept = default;

  using iterator = const char *;
  using const_iterator = const char *;
  const_iterator begin() const noexcept;
  const_iterator end() const noexcept;
  const_iterator cbegin() const noexcept;
  const_iterator cend() const noexcept;

  bool operator==(const Str &) const noexcept;
  bool operator!=(const Str &) const noexcept;
  bool operator<(const Str &) const noexcept;
  bool operator<=(const Str &) const noexcept;
  bool operator>(const Str &) const noexcept;
  bool operator>=(const Str &) const noexcept;

  void swap(Str &) noexcept;

private:
  class uninit;
  Str(uninit) noexcept;
  friend impl<Str>;

  std::array<std::uintptr_t, 2> repr;
};
#endif // CXXBRIDGE1_RUST_STR

#ifndef CXXBRIDGE1_IS_COMPLETE
#define CXXBRIDGE1_IS_COMPLETE
namespace detail {
namespace {
template <typename T, typename = std::size_t>
struct is_complete : std::false_type {};
template <typename T>
struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
} // namespace
} // namespace detail
#endif // CXXBRIDGE1_IS_COMPLETE

#ifndef CXXBRIDGE1_RELOCATABLE
#define CXXBRIDGE1_RELOCATABLE
namespace detail {
template <typename... Ts>
struct make_void {
  using type = void;
};

template <typename... Ts>
using void_t = typename make_void<Ts...>::type;

template <typename Void, template <typename...> class, typename...>
struct detect : std::false_type {};
template <template <typename...> class T, typename... A>
struct detect<void_t<T<A...>>, T, A...> : std::true_type {};

template <template <typename...> class T, typename... A>
using is_detected = detect<void, T, A...>;

template <typename T>
using detect_IsRelocatable = typename T::IsRelocatable;

template <typename T>
struct get_IsRelocatable
    : std::is_same<typename T::IsRelocatable, std::true_type> {};
} // namespace detail

template <typename T>
struct IsRelocatable
    : std::conditional<
          detail::is_detected<detail::detect_IsRelocatable, T>::value,
          detail::get_IsRelocatable<T>,
          std::integral_constant<
              bool, std::is_trivially_move_constructible<T>::value &&
                        std::is_trivially_destructible<T>::value>>::type {};
#endif // CXXBRIDGE1_RELOCATABLE

namespace detail {
template <typename T, typename = void *>
struct operator_new {
  void *operator()(::std::size_t sz) { return ::operator new(sz); }
};

template <typename T>
struct operator_new<T, decltype(T::operator new(sizeof(T)))> {
  void *operator()(::std::size_t sz) { return T::operator new(sz); }
};
} // namespace detail

template <typename T>
union MaybeUninit {
  T value;
  void *operator new(::std::size_t sz) { return detail::operator_new<T>{}(sz); }
  MaybeUninit() {}
  ~MaybeUninit() {}
};

namespace {
template <typename T>
void destroy(T *ptr) {
  ptr->~T();
}

template <bool> struct deleter_if {
  template <typename T> void operator()(T *) {}
};

template <> struct deleter_if<true> {
  template <typename T> void operator()(T *ptr) { ptr->~T(); }
};
} // namespace
} // namespace cxxbridge1
} // namespace rust

using std_reverse_iterator_iterator_AutocxxConcrete = ::std_reverse_iterator_iterator_AutocxxConcrete;
using std_reverse_iterator_uint64_t_AutocxxConcrete = ::std_reverse_iterator_uint64_t_AutocxxConcrete;
using boost_uniform_real_double_AutocxxConcrete = ::boost_uniform_real_double_AutocxxConcrete;
using boost_adjacency_list_boost_no_property_AutocxxConcrete = ::boost_adjacency_list_boost_no_property_AutocxxConcrete;
using std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete = ::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete;
using std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete = ::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete;
using std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete = ::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete;
using std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete = ::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete;
using std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete = ::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete;
namespace RDKit {
  using INT_LIST = ::RDKit::INT_LIST;
  using LIST_INT_VECT = ::RDKit::LIST_INT_VECT;
  using VECT_INT_VECT = ::RDKit::VECT_INT_VECT;
  using STR_UINT_MAP = ::RDKit::STR_UINT_MAP;
  using INT_INT_VECT_MAP = ::RDKit::INT_INT_VECT_MAP;
  using INT_MAP_INT = ::RDKit::INT_MAP_INT;
  using INT_DEQUE = ::RDKit::INT_DEQUE;
  using INT_INT_DEQ_MAP = ::RDKit::INT_INT_DEQ_MAP;
  using INT_SET = ::RDKit::INT_SET;
  using DOUBLE_INT_MAP = ::RDKit::DOUBLE_INT_MAP;
  using RWMol = ::RDKit::RWMol;
  using AtomMonomerInfo = ::RDKit::AtomMonomerInfo;
  using CONFORMER_SPTR = ::RDKit::CONFORMER_SPTR;
  using MolPickler = ::RDKit::MolPickler;
  using QueryAtom = ::RDKit::QueryAtom;
  using QueryBond = ::RDKit::QueryBond;
  using BondIterator_ = ::RDKit::BondIterator_;
  using ConstBondIterator_ = ::RDKit::ConstBondIterator_;
  using ROMOL_SPTR = ::RDKit::ROMOL_SPTR;
  namespace Utils {
    namespace detail {
      using LocaleSwitcherImpl = ::RDKit::Utils::detail::LocaleSwitcherImpl;
    }
  }
  namespace ROMol {
    using AtomIterator = ::RDKit::ROMol::AtomIterator;
    using ConstAtomIterator = ::RDKit::ROMol::ConstAtomIterator;
    using AromaticAtomIterator = ::RDKit::ROMol::AromaticAtomIterator;
    using ConstAromaticAtomIterator = ::RDKit::ROMol::ConstAromaticAtomIterator;
    using HeteroatomIterator = ::RDKit::ROMol::HeteroatomIterator;
    using ConstHeteroatomIterator = ::RDKit::ROMol::ConstHeteroatomIterator;
    using QueryAtomIterator = ::RDKit::ROMol::QueryAtomIterator;
    using ConstQueryAtomIterator = ::RDKit::ROMol::ConstQueryAtomIterator;
    using MatchingAtomIterator = ::RDKit::ROMol::MatchingAtomIterator;
    using ConstMatchingAtomIterator = ::RDKit::ROMol::ConstMatchingAtomIterator;
  }
}
namespace std {
  using ostream = ::std::ostream;
}

static_assert(
    ::rust::IsRelocatable<::RDKit::Atom::HybridizationType>::value,
    "type RDKit::Atom::HybridizationType should be trivially move constructible and trivially destructible in C++ to be used as an argument of `setHybridization` or return value of `getHybridization` in Rust");
static_assert(
    ::rust::IsRelocatable<::RDKit::Atom::ChiralType>::value,
    "type RDKit::Atom::ChiralType should be trivially move constructible and trivially destructible in C++ to be used as an argument of `setChiralTag` or return value of `getChiralTag` in Rust");
static_assert(
    ::rust::IsRelocatable<::RDKit::Bond::BondType>::value,
    "type RDKit::Bond::BondType should be trivially move constructible and trivially destructible in C++ to be used as an argument of `setBondType`, `RDKit_Bond_new1_autocxx_wrapper_0x7001b89d03cdd863` or return value of `getBondType` in Rust");
static_assert(
    ::rust::IsRelocatable<::RDKit::Bond::BondDir>::value,
    "type RDKit::Bond::BondDir should be trivially move constructible and trivially destructible in C++ to be used as an argument of `setBondDir` or return value of `getBondDir` in Rust");
static_assert(
    ::rust::IsRelocatable<::RDKit::Bond::BondStereo>::value,
    "type RDKit::Bond::BondStereo should be trivially move constructible and trivially destructible in C++ to be used as an argument of `setStereo` or return value of `getStereo` in Rust");
static_assert(
    ::rust::IsRelocatable<::RDKit::SubstanceGroup::BondType>::value,
    "type RDKit::SubstanceGroup::BondType should be trivially move constructible and trivially destructible in C++ to be used as a return value of `RDKit_SubstanceGroup_getBondType_autocxx_wrapper_0x7001b89d03cdd863` in Rust");
static_assert(
    ::rust::IsRelocatable<::RDKit::StereoGroupType>::value,
    "type RDKit::StereoGroupType should be trivially move constructible and trivially destructible in C++ to be used as a return value of `getGroupType` in Rust");
static_assert(
    ::rust::IsRelocatable<::Queries::CompositeQueryType>::value,
    "type Queries::CompositeQueryType should be trivially move constructible and trivially destructible in C++ to be used as an argument of `expandQuery_autocxx_wrapper_0x7001b89d03cdd863`, `RDKit_Bond_expandQuery_autocxx_wrapper_0x7001b89d03cdd863` in Rust");
static_assert(
    ::rust::IsRelocatable<::c_int>::value,
    "type c_int should be trivially move constructible and trivially destructible in C++ to be used as an argument of `RDKit_RDTypeTag_detail_Value_new3_autocxx_wrapper_0x7001b89d03cdd863`, `RDKit_RDValue_new3_autocxx_wrapper_0x7001b89d03cdd863`, `setVal3` or return value of `rdvalue_cast2_autocxx_wrapper_0x7001b89d03cdd863`, `getAtomicNum`, `getExplicitValence` in Rust");
static_assert(
    ::rust::IsRelocatable<::c_uint>::value,
    "type c_uint should be trivially move constructible and trivially destructible in C++ to be used as an argument of `RDKit_RDTypeTag_detail_Value_new4_autocxx_wrapper_0x7001b89d03cdd863`, `isSubstanceGroupIdFree`, `RDKit_RDValue_new4_autocxx_wrapper_0x7001b89d03cdd863` or return value of `rdvalue_cast6_autocxx_wrapper_0x7001b89d03cdd863`, `getIdx`, `getDegree` in Rust");
static_assert(
    ::rust::IsRelocatable<::c_short>::value,
    "type c_short should be trivially move constructible and trivially destructible in C++ to be used as a return value of `GetTag`, `GetTag1`, `GetTag2` in Rust");
static_assert(
    ::rust::IsRelocatable<::c_longlong>::value,
    "type c_longlong should be trivially move constructible and trivially destructible in C++ to be used as a return value of `rdvalue_cast5_autocxx_wrapper_0x7001b89d03cdd863` in Rust");
static_assert(
    ::rust::IsRelocatable<::c_ushort>::value,
    "type c_ushort should be trivially move constructible and trivially destructible in C++ to be used as a return value of `rdvalue_cast8_autocxx_wrapper_0x7001b89d03cdd863` in Rust");
static_assert(
    ::rust::IsRelocatable<::c_ulonglong>::value,
    "type c_ulonglong should be trivially move constructible and trivially destructible in C++ to be used as a return value of `rdvalue_cast9_autocxx_wrapper_0x7001b89d03cdd863` in Rust");

extern "C" {
::std::string *cxxbridge1$autocxx_make_string_0x7001b89d03cdd863(::rust::Str str_) noexcept {
  ::std::unique_ptr<::std::string> (*autocxx_make_string_0x7001b89d03cdd863$)(::rust::Str) = ::autocxx_make_string_0x7001b89d03cdd863;
  return autocxx_make_string_0x7001b89d03cdd863$(str_).release();
}

::RDKit::Utils::LocaleSwitcher *cxxbridge1$LocaleSwitcher_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::Utils::LocaleSwitcher *(*LocaleSwitcher_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::LocaleSwitcher_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return LocaleSwitcher_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$LocaleSwitcher_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Utils::LocaleSwitcher *arg0) noexcept {
  void (*LocaleSwitcher_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Utils::LocaleSwitcher *) = ::LocaleSwitcher_free_autocxx_wrapper_0x7001b89d03cdd863;
  LocaleSwitcher_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

void cxxbridge1$RDKit_Utils_LocaleSwitcher_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Utils::LocaleSwitcher *autocxx_gen_this) noexcept {
  void (*RDKit_Utils_LocaleSwitcher_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Utils::LocaleSwitcher *) = ::RDKit_Utils_LocaleSwitcher_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Utils_LocaleSwitcher_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$LocaleSwitcher_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Utils::LocaleSwitcher *autocxx_gen_this) noexcept {
  void (*LocaleSwitcher_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Utils::LocaleSwitcher *) = ::LocaleSwitcher_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  LocaleSwitcher_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::RDKit::RDTypeTag::detail::Value *cxxbridge1$Value_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::RDTypeTag::detail::Value *(*Value_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::Value_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return Value_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$Value_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *arg0) noexcept {
  void (*Value_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *) = ::Value_free_autocxx_wrapper_0x7001b89d03cdd863;
  Value_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *) = ::RDKit_RDTypeTag_detail_Value_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, double v) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, double) = ::RDKit_RDTypeTag_detail_Value_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, float v) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, float) = ::RDKit_RDTypeTag_detail_Value_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::c_int *v) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::c_int) = ::RDKit_RDTypeTag_detail_Value_new3_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new3_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*v));
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new4_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::c_uint *v) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new4_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::c_uint) = ::RDKit_RDTypeTag_detail_Value_new4_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new4_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*v));
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new5_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, bool v) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new5_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, bool) = ::RDKit_RDTypeTag_detail_Value_new5_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new5_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new6_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::std::string *v) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new6_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::std::string *) = ::RDKit_RDTypeTag_detail_Value_new6_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new6_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$new7_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::boost::any *v) noexcept {
  void (*new7_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::boost::any *) = ::new7_autocxx_wrapper_0x7001b89d03cdd863;
  new7_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$new8_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::std::vector<double> *v) noexcept {
  void (*new8_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::std::vector<double> *) = ::new8_autocxx_wrapper_0x7001b89d03cdd863;
  new8_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$new9_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::std::vector<float> *v) noexcept {
  void (*new9_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::std::vector<float> *) = ::new9_autocxx_wrapper_0x7001b89d03cdd863;
  new9_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$new12_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::std::vector<::std::string> *v) noexcept {
  void (*new12_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::std::vector<::std::string> *) = ::new12_autocxx_wrapper_0x7001b89d03cdd863;
  new12_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

::boost::any *cxxbridge1$valuePtrCast_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *value) noexcept {
  ::boost::any *(*valuePtrCast_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *) = ::valuePtrCast_autocxx_wrapper_0x7001b89d03cdd863;
  return valuePtrCast_autocxx_wrapper_0x7001b89d03cdd863$(value);
}

::std::string *cxxbridge1$valuePtrCast1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *value) noexcept {
  ::std::string *(*valuePtrCast1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *) = ::valuePtrCast1_autocxx_wrapper_0x7001b89d03cdd863;
  return valuePtrCast1_autocxx_wrapper_0x7001b89d03cdd863$(value);
}

::std::vector<double> *cxxbridge1$valuePtrCast2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *value) noexcept {
  ::std::vector<double> *(*valuePtrCast2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *) = ::valuePtrCast2_autocxx_wrapper_0x7001b89d03cdd863;
  return valuePtrCast2_autocxx_wrapper_0x7001b89d03cdd863$(value);
}

::std::vector<float> *cxxbridge1$valuePtrCast3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *value) noexcept {
  ::std::vector<float> *(*valuePtrCast3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *) = ::valuePtrCast3_autocxx_wrapper_0x7001b89d03cdd863;
  return valuePtrCast3_autocxx_wrapper_0x7001b89d03cdd863$(value);
}

::std::vector<::std::string> *cxxbridge1$valuePtrCast6_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *value) noexcept {
  ::std::vector<::std::string> *(*valuePtrCast6_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *) = ::valuePtrCast6_autocxx_wrapper_0x7001b89d03cdd863;
  return valuePtrCast6_autocxx_wrapper_0x7001b89d03cdd863$(value);
}
} // extern "C"

namespace RDKit {
namespace RDTypeTag {
extern "C" {
void RDKit$RDTypeTag$cxxbridge1$GetTag(::c_short *return$) noexcept {
  ::c_short (*GetTag$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag1(::c_short *return$) noexcept {
  ::c_short (*GetTag1$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag1$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag2(::c_short *return$) noexcept {
  ::c_short (*GetTag2$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag2$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag3(::c_short *return$) noexcept {
  ::c_short (*GetTag3$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag3$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag4(::c_short *return$) noexcept {
  ::c_short (*GetTag4$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag4$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag5(::c_short *return$) noexcept {
  ::c_short (*GetTag5$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag5$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag6(::c_short *return$) noexcept {
  ::c_short (*GetTag6$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag6$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag7(::c_short *return$) noexcept {
  ::c_short (*GetTag7$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag7$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag8(::c_short *return$) noexcept {
  ::c_short (*GetTag8$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag8$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag9(::c_short *return$) noexcept {
  ::c_short (*GetTag9$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag9$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag10(::c_short *return$) noexcept {
  ::c_short (*GetTag10$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag10$());
}

void RDKit$RDTypeTag$cxxbridge1$GetTag11(::c_short *return$) noexcept {
  ::c_short (*GetTag11$)() = ::RDKit::RDTypeTag::GetTag;
  new (return$) ::c_short(GetTag11$());
}
} // extern "C"
} // namespace RDTypeTag
} // namespace RDKit

extern "C" {
::RDKit::RDValue *cxxbridge1$RDValue_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::RDValue *(*RDValue_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::RDValue_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return RDValue_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$RDValue_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *arg0) noexcept {
  void (*RDValue_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::RDValue_free_autocxx_wrapper_0x7001b89d03cdd863;
  RDValue_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::RDAny *cxxbridge1$RDAny_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::RDAny *(*RDAny_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::RDAny_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return RDAny_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$RDAny_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDAny *arg0) noexcept {
  void (*RDAny_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDAny *) = ::RDAny_free_autocxx_wrapper_0x7001b89d03cdd863;
  RDAny_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::Dict *cxxbridge1$Dict_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::Dict *(*Dict_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::Dict_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return Dict_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$Dict_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict *arg0) noexcept {
  void (*Dict_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict *) = ::Dict_free_autocxx_wrapper_0x7001b89d03cdd863;
  Dict_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::Dict::Pair *cxxbridge1$Dict_Pair_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::Dict::Pair *(*Dict_Pair_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::Dict_Pair_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return Dict_Pair_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$Dict_Pair_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict::Pair *arg0) noexcept {
  void (*Dict_Pair_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict::Pair *) = ::Dict_Pair_free_autocxx_wrapper_0x7001b89d03cdd863;
  Dict_Pair_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::ltDouble *cxxbridge1$ltDouble_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::ltDouble *(*ltDouble_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::ltDouble_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return ltDouble_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$ltDouble_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ltDouble *arg0) noexcept {
  void (*ltDouble_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ltDouble *) = ::ltDouble_free_autocxx_wrapper_0x7001b89d03cdd863;
  ltDouble_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::charptr_functor *cxxbridge1$charptr_functor_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::charptr_functor *(*charptr_functor_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::charptr_functor_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return charptr_functor_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$charptr_functor_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::charptr_functor *arg0) noexcept {
  void (*charptr_functor_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::charptr_functor *) = ::charptr_functor_free_autocxx_wrapper_0x7001b89d03cdd863;
  charptr_functor_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::RDProps *cxxbridge1$RDProps_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::RDProps *(*RDProps_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::RDProps_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return RDProps_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$RDProps_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDProps *arg0) noexcept {
  void (*RDProps_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDProps *) = ::RDProps_free_autocxx_wrapper_0x7001b89d03cdd863;
  RDProps_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::RDProps const *cxxbridge1$cast_Atom_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const &autocxx_gen_this) noexcept {
  ::RDKit::RDProps const &(*cast_Atom_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const &) = ::cast_Atom_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863;
  return &cast_Atom_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::RDKit::Atom *cxxbridge1$Atom_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::Atom *(*Atom_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::Atom_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return Atom_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$Atom_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom *arg0) noexcept {
  void (*Atom_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom *) = ::Atom_free_autocxx_wrapper_0x7001b89d03cdd863;
  Atom_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::RDProps const *cxxbridge1$cast_Bond_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this) noexcept {
  ::RDKit::RDProps const &(*cast_Bond_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &) = ::cast_Bond_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863;
  return &cast_Bond_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::RDKit::Bond *cxxbridge1$Bond_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::Bond *(*Bond_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::Bond_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return Bond_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$Bond_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond *arg0) noexcept {
  void (*Bond_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond *) = ::Bond_free_autocxx_wrapper_0x7001b89d03cdd863;
  Bond_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::ConformerException *cxxbridge1$ConformerException_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::ConformerException *(*ConformerException_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::ConformerException_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return ConformerException_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$ConformerException_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ConformerException *arg0) noexcept {
  void (*ConformerException_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ConformerException *) = ::ConformerException_free_autocxx_wrapper_0x7001b89d03cdd863;
  ConformerException_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::RDProps const *cxxbridge1$cast_Conformer_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Conformer const &autocxx_gen_this) noexcept {
  ::RDKit::RDProps const &(*cast_Conformer_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Conformer const &) = ::cast_Conformer_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863;
  return &cast_Conformer_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::RDKit::Conformer *cxxbridge1$Conformer_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::Conformer *(*Conformer_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::Conformer_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return Conformer_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$Conformer_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Conformer *arg0) noexcept {
  void (*Conformer_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Conformer *) = ::Conformer_free_autocxx_wrapper_0x7001b89d03cdd863;
  Conformer_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::SubstanceGroupException *cxxbridge1$SubstanceGroupException_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::SubstanceGroupException *(*SubstanceGroupException_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::SubstanceGroupException_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return SubstanceGroupException_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$SubstanceGroupException_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroupException *arg0) noexcept {
  void (*SubstanceGroupException_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroupException *) = ::SubstanceGroupException_free_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroupException_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::RDProps const *cxxbridge1$cast_SubstanceGroup_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup const &autocxx_gen_this) noexcept {
  ::RDKit::RDProps const &(*cast_SubstanceGroup_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup const &) = ::cast_SubstanceGroup_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863;
  return &cast_SubstanceGroup_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::RDKit::SubstanceGroup *cxxbridge1$SubstanceGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::SubstanceGroup *(*SubstanceGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::SubstanceGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return SubstanceGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$SubstanceGroup_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup *arg0) noexcept {
  void (*SubstanceGroup_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup *) = ::SubstanceGroup_free_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::SubstanceGroup::AttachPoint *cxxbridge1$SubstanceGroup_AttachPoint_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::SubstanceGroup::AttachPoint *(*SubstanceGroup_AttachPoint_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::SubstanceGroup_AttachPoint_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return SubstanceGroup_AttachPoint_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$SubstanceGroup_AttachPoint_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::AttachPoint *arg0) noexcept {
  void (*SubstanceGroup_AttachPoint_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::AttachPoint *) = ::SubstanceGroup_AttachPoint_free_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_AttachPoint_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::SubstanceGroup::CState *cxxbridge1$SubstanceGroup_CState_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::SubstanceGroup::CState *(*SubstanceGroup_CState_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::SubstanceGroup_CState_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return SubstanceGroup_CState_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$SubstanceGroup_CState_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::CState *arg0) noexcept {
  void (*SubstanceGroup_CState_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::CState *) = ::SubstanceGroup_CState_free_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_CState_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}
} // extern "C"

namespace RDKit {
namespace SubstanceGroupChecks {
extern "C" {
bool RDKit$SubstanceGroupChecks$cxxbridge1$isValidType(::std::string const &type_) noexcept {
  bool (*isValidType$)(::std::string const &) = ::RDKit::SubstanceGroupChecks::isValidType;
  return isValidType$(type_);
}

bool RDKit$SubstanceGroupChecks$cxxbridge1$isValidSubType(::std::string const &type_) noexcept {
  bool (*isValidSubType$)(::std::string const &) = ::RDKit::SubstanceGroupChecks::isValidSubType;
  return isValidSubType$(type_);
}

bool RDKit$SubstanceGroupChecks$cxxbridge1$isValidConnectType(::std::string const &type_) noexcept {
  bool (*isValidConnectType$)(::std::string const &) = ::RDKit::SubstanceGroupChecks::isValidConnectType;
  return isValidConnectType$(type_);
}

bool RDKit$SubstanceGroupChecks$cxxbridge1$isSubstanceGroupIdFree(::RDKit::ROMol const &mol, ::c_uint *id) noexcept {
  bool (*isSubstanceGroupIdFree$)(::RDKit::ROMol const &, ::c_uint) = ::RDKit::SubstanceGroupChecks::isSubstanceGroupIdFree;
  return isSubstanceGroupIdFree$(mol, ::std::move(*id));
}
} // extern "C"
} // namespace SubstanceGroupChecks
} // namespace RDKit

extern "C" {
::RDKit::StereoGroup *cxxbridge1$StereoGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::StereoGroup *(*StereoGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::StereoGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return StereoGroup_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$StereoGroup_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::StereoGroup *arg0) noexcept {
  void (*StereoGroup_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::StereoGroup *) = ::StereoGroup_free_autocxx_wrapper_0x7001b89d03cdd863;
  StereoGroup_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::RingInfo *cxxbridge1$RingInfo_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::RingInfo *(*RingInfo_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::RingInfo_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return RingInfo_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$RingInfo_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RingInfo *arg0) noexcept {
  void (*RingInfo_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RingInfo *) = ::RingInfo_free_autocxx_wrapper_0x7001b89d03cdd863;
  RingInfo_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

::RDKit::RDProps const *cxxbridge1$cast_ROMol_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol const &autocxx_gen_this) noexcept {
  ::RDKit::RDProps const &(*cast_ROMol_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol const &) = ::cast_ROMol_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863;
  return &cast_ROMol_to_RDProps_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::RDKit::ROMol *cxxbridge1$ROMol_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDKit::ROMol *(*ROMol_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::ROMol_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return ROMol_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$ROMol_free_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol *arg0) noexcept {
  void (*ROMol_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol *) = ::ROMol_free_autocxx_wrapper_0x7001b89d03cdd863;
  ROMol_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$RDValue$getTag(::RDKit::RDValue const &self, ::c_short *return$) noexcept {
  ::c_short (::RDKit::RDValue::*getTag$)() const = &::RDKit::RDValue::getTag;
  new (return$) ::c_short((self.*getTag$)());
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_RDValue_destroy_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue &autocxx_gen_this) noexcept {
  void (*RDKit_RDValue_destroy_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue &) = ::RDKit_RDValue_destroy_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_destroy_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$cleanup_rdvalue_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue &rdvalue) noexcept {
  void (*cleanup_rdvalue_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue &) = ::cleanup_rdvalue_autocxx_wrapper_0x7001b89d03cdd863;
  cleanup_rdvalue_autocxx_wrapper_0x7001b89d03cdd863$(rdvalue);
}

void cxxbridge1$RDKit_RDValue_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this) noexcept {
  void (*RDKit_RDValue_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::RDKit_RDValue_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_RDValue_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, double v) noexcept {
  void (*RDKit_RDValue_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, double) = ::RDKit_RDValue_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDValue_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, float v) noexcept {
  void (*RDKit_RDValue_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, float) = ::RDKit_RDValue_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDValue_new3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::c_int *v) noexcept {
  void (*RDKit_RDValue_new3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::c_int) = ::RDKit_RDValue_new3_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new3_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*v));
}

void cxxbridge1$RDKit_RDValue_new4_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::c_uint *v) noexcept {
  void (*RDKit_RDValue_new4_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::c_uint) = ::RDKit_RDValue_new4_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new4_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*v));
}

void cxxbridge1$RDKit_RDValue_new5_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, bool v) noexcept {
  void (*RDKit_RDValue_new5_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, bool) = ::RDKit_RDValue_new5_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new5_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDValue_new6_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::boost::any *v) noexcept {
  void (*RDKit_RDValue_new6_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::boost::any *) = ::RDKit_RDValue_new6_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new6_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDValue_new7_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::boost::any const &v) noexcept {
  void (*RDKit_RDValue_new7_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::boost::any const &) = ::RDKit_RDValue_new7_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new7_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDValue_new8_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::std::string const &v) noexcept {
  void (*RDKit_RDValue_new8_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::std::string const &) = ::RDKit_RDValue_new8_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new8_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDValue_new9_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::std::vector<double> const &v) noexcept {
  void (*RDKit_RDValue_new9_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::std::vector<double> const &) = ::RDKit_RDValue_new9_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new9_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$RDKit_RDValue_new10_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::std::vector<float> const &v) noexcept {
  void (*RDKit_RDValue_new10_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::std::vector<float> const &) = ::RDKit_RDValue_new10_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new10_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}

void cxxbridge1$new13_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::std::vector<::std::string> const &v) noexcept {
  void (*new13_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::std::vector<::std::string> const &) = ::new13_autocxx_wrapper_0x7001b89d03cdd863;
  new13_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, v);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$copy_rdvalue(::RDKit::RDValue &dest, ::RDKit::RDValue const &src) noexcept {
  void (*copy_rdvalue$)(::RDKit::RDValue &, ::RDKit::RDValue const &) = ::RDKit::copy_rdvalue;
  copy_rdvalue$(dest, src);
}
} // extern "C"
} // namespace RDKit

extern "C" {
bool cxxbridge1$rdvalue_is_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  bool (*rdvalue_is_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_is_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_is_autocxx_wrapper_0x7001b89d03cdd863$(v);
}

double cxxbridge1$rdvalue_cast_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  double (*rdvalue_cast_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast_autocxx_wrapper_0x7001b89d03cdd863$(v);
}

float cxxbridge1$rdvalue_cast1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  float (*rdvalue_cast1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast1_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast1_autocxx_wrapper_0x7001b89d03cdd863$(v);
}

void cxxbridge1$rdvalue_cast2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v, ::c_int *return$) noexcept {
  ::c_int (*rdvalue_cast2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast2_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_int(rdvalue_cast2_autocxx_wrapper_0x7001b89d03cdd863$(v));
}

::std::int8_t cxxbridge1$rdvalue_cast3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  ::std::int8_t (*rdvalue_cast3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast3_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast3_autocxx_wrapper_0x7001b89d03cdd863$(v);
}

void cxxbridge1$rdvalue_cast4_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v, ::c_short *return$) noexcept {
  ::c_short (*rdvalue_cast4_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast4_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_short(rdvalue_cast4_autocxx_wrapper_0x7001b89d03cdd863$(v));
}

void cxxbridge1$rdvalue_cast5_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v, ::c_longlong *return$) noexcept {
  ::c_longlong (*rdvalue_cast5_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast5_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_longlong(rdvalue_cast5_autocxx_wrapper_0x7001b89d03cdd863$(v));
}

void cxxbridge1$rdvalue_cast6_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v, ::c_uint *return$) noexcept {
  ::c_uint (*rdvalue_cast6_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast6_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_uint(rdvalue_cast6_autocxx_wrapper_0x7001b89d03cdd863$(v));
}

::std::uint8_t cxxbridge1$rdvalue_cast7_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  ::std::uint8_t (*rdvalue_cast7_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast7_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast7_autocxx_wrapper_0x7001b89d03cdd863$(v);
}

void cxxbridge1$rdvalue_cast8_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v, ::c_ushort *return$) noexcept {
  ::c_ushort (*rdvalue_cast8_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast8_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_ushort(rdvalue_cast8_autocxx_wrapper_0x7001b89d03cdd863$(v));
}

void cxxbridge1$rdvalue_cast9_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v, ::c_ulonglong *return$) noexcept {
  ::c_ulonglong (*rdvalue_cast9_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast9_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_ulonglong(rdvalue_cast9_autocxx_wrapper_0x7001b89d03cdd863$(v));
}

bool cxxbridge1$rdvalue_cast10_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  bool (*rdvalue_cast10_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast10_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast10_autocxx_wrapper_0x7001b89d03cdd863$(v);
}

::std::string *cxxbridge1$rdvalue_cast11_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  ::std::unique_ptr<::std::string> (*rdvalue_cast11_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast11_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast11_autocxx_wrapper_0x7001b89d03cdd863$(v).release();
}

::std::vector<double> *cxxbridge1$rdvalue_cast13_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  ::std::unique_ptr<::std::vector<double>> (*rdvalue_cast13_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast13_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast13_autocxx_wrapper_0x7001b89d03cdd863$(v).release();
}

::std::vector<float> *cxxbridge1$rdvalue_cast15_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  ::std::unique_ptr<::std::vector<float>> (*rdvalue_cast15_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast15_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast15_autocxx_wrapper_0x7001b89d03cdd863$(v).release();
}

::std::vector<::std::string> *cxxbridge1$rdvalue_cast17_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v) noexcept {
  ::std::unique_ptr<::std::vector<::std::string>> (*rdvalue_cast17_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::rdvalue_cast17_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_cast17_autocxx_wrapper_0x7001b89d03cdd863$(v).release();
}

void cxxbridge1$rdvalue_cast23_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *v, ::boost::any *placement_return_type) noexcept {
  void (*rdvalue_cast23_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::boost::any *) = ::rdvalue_cast23_autocxx_wrapper_0x7001b89d03cdd863;
  rdvalue_cast23_autocxx_wrapper_0x7001b89d03cdd863$(v, placement_return_type);
}

bool cxxbridge1$rdvalue_tostring_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *val, ::std::string &res) noexcept {
  bool (*rdvalue_tostring_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::std::string &) = ::rdvalue_tostring_autocxx_wrapper_0x7001b89d03cdd863;
  return rdvalue_tostring_autocxx_wrapper_0x7001b89d03cdd863$(val, res);
}

void cxxbridge1$RDKit_RDAny_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDAny *autocxx_gen_this) noexcept {
  void (*RDKit_RDAny_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDAny *) = ::RDKit_RDAny_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDAny_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_RDAny_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDAny *autocxx_gen_this, ::RDKit::RDAny const &rhs) noexcept {
  void (*RDKit_RDAny_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDAny *, ::RDKit::RDAny const &) = ::RDKit_RDAny_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDAny_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, rhs);
}

void cxxbridge1$RDAny_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDAny *autocxx_gen_this) noexcept {
  void (*RDAny_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDAny *) = ::RDAny_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  RDAny_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Dict_Pair_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict::Pair *autocxx_gen_this) noexcept {
  void (*RDKit_Dict_Pair_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict::Pair *) = ::RDKit_Dict_Pair_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Dict_Pair_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Dict_Pair_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict::Pair *autocxx_gen_this, ::std::string *s) noexcept {
  void (*RDKit_Dict_Pair_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict::Pair *, ::std::unique_ptr<::std::string>) = ::RDKit_Dict_Pair_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Dict_Pair_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::unique_ptr<::std::string>(s));
}

void cxxbridge1$RDKit_Dict_Pair_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict::Pair *autocxx_gen_this, ::std::string *s, ::RDKit::RDValue const &v) noexcept {
  void (*RDKit_Dict_Pair_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict::Pair *, ::std::unique_ptr<::std::string>, ::RDKit::RDValue const &) = ::RDKit_Dict_Pair_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Dict_Pair_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::unique_ptr<::std::string>(s), v);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$Dict$update(::RDKit::Dict &self, ::RDKit::Dict const &other, bool preserveExisting) noexcept {
  void (::RDKit::Dict::*update$)(::RDKit::Dict const &, bool) = &::RDKit::Dict::update;
  (self.*update$)(other, preserveExisting);
}

bool *RDKit$cxxbridge1$Dict$getNonPODStatus(::RDKit::Dict &self) noexcept {
  bool &(::RDKit::Dict::*getNonPODStatus$)() = &::RDKit::Dict::getNonPODStatus;
  return &(self.*getNonPODStatus$)();
}

::std::vector<::RDKit::Dict::Pair> const *RDKit$cxxbridge1$Dict$getData(::RDKit::Dict const &self) noexcept {
  ::std::vector<::RDKit::Dict::Pair> const &(::RDKit::Dict::*getData$)() const = &::RDKit::Dict::getData;
  return &(self.*getData$)();
}

::std::vector<::RDKit::Dict::Pair> *RDKit$cxxbridge1$Dict$getData1(::RDKit::Dict &self) noexcept {
  ::std::vector<::RDKit::Dict::Pair> &(::RDKit::Dict::*getData1$)() = &::RDKit::Dict::getData;
  return &(self.*getData1$)();
}

bool RDKit$cxxbridge1$Dict$hasVal(::RDKit::Dict const &self, ::std::string const &what) noexcept {
  bool (::RDKit::Dict::*hasVal$)(::std::string const &) const = &::RDKit::Dict::hasVal;
  return (self.*hasVal$)(what);
}
} // extern "C"
} // namespace RDKit

extern "C" {
::std::vector<::std::string> *cxxbridge1$keys_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict const &autocxx_gen_this) noexcept {
  ::std::unique_ptr<::std::vector<::std::string>> (*keys_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict const &) = ::keys_autocxx_wrapper_0x7001b89d03cdd863;
  return keys_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this).release();
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$Dict$getVal(::RDKit::Dict const &self, ::std::string const &what, ::std::string &res) noexcept {
  void (::RDKit::Dict::*getVal$)(::std::string const &, ::std::string &) const = &::RDKit::Dict::getVal;
  (self.*getVal$)(what, res);
}

bool RDKit$cxxbridge1$Dict$getValIfPresent(::RDKit::Dict const &self, ::std::string const &what, ::std::string &res) noexcept {
  bool (::RDKit::Dict::*getValIfPresent$)(::std::string const &, ::std::string &) const = &::RDKit::Dict::getValIfPresent;
  return (self.*getValIfPresent$)(what, res);
}

void RDKit$cxxbridge1$Dict$setVal(::RDKit::Dict &self, ::std::string const &what, bool val) noexcept {
  void (::RDKit::Dict::*setVal$)(::std::string const &, bool) = &::RDKit::Dict::setVal;
  (self.*setVal$)(what, val);
}

void RDKit$cxxbridge1$Dict$setVal1(::RDKit::Dict &self, ::std::string const &what, double val) noexcept {
  void (::RDKit::Dict::*setVal1$)(::std::string const &, double) = &::RDKit::Dict::setVal;
  (self.*setVal1$)(what, val);
}

void RDKit$cxxbridge1$Dict$setVal2(::RDKit::Dict &self, ::std::string const &what, float val) noexcept {
  void (::RDKit::Dict::*setVal2$)(::std::string const &, float) = &::RDKit::Dict::setVal;
  (self.*setVal2$)(what, val);
}

void RDKit$cxxbridge1$Dict$setVal3(::RDKit::Dict &self, ::std::string const &what, ::c_int *val) noexcept {
  void (::RDKit::Dict::*setVal3$)(::std::string const &, ::c_int) = &::RDKit::Dict::setVal;
  (self.*setVal3$)(what, ::std::move(*val));
}

void RDKit$cxxbridge1$Dict$setVal4(::RDKit::Dict &self, ::std::string const &what, ::c_uint *val) noexcept {
  void (::RDKit::Dict::*setVal4$)(::std::string const &, ::c_uint) = &::RDKit::Dict::setVal;
  (self.*setVal4$)(what, ::std::move(*val));
}

void RDKit$cxxbridge1$Dict$setVal5(::RDKit::Dict &self, ::std::string const &what, char const *val) noexcept {
  void (::RDKit::Dict::*setVal5$)(::std::string const &, char const *) = &::RDKit::Dict::setVal;
  (self.*setVal5$)(what, val);
}

void RDKit$cxxbridge1$Dict$clearVal(::RDKit::Dict &self, ::std::string const &what) noexcept {
  void (::RDKit::Dict::*clearVal$)(::std::string const &) = &::RDKit::Dict::clearVal;
  (self.*clearVal$)(what);
}

void RDKit$cxxbridge1$Dict$reset(::RDKit::Dict &self) noexcept {
  void (::RDKit::Dict::*reset$)() = &::RDKit::Dict::reset;
  (self.*reset$)();
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_Dict_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict *autocxx_gen_this) noexcept {
  void (*RDKit_Dict_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict *) = ::RDKit_Dict_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Dict_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Dict_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict *autocxx_gen_this, ::RDKit::Dict const &other) noexcept {
  void (*RDKit_Dict_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict *, ::RDKit::Dict const &) = ::RDKit_Dict_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Dict_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_Dict_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict *autocxx_gen_this, ::RDKit::Dict *other) noexcept {
  void (*RDKit_Dict_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict *, ::RDKit::Dict *) = ::RDKit_Dict_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Dict_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$Dict_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict *autocxx_gen_this) noexcept {
  void (*Dict_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict *) = ::Dict_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  Dict_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_ltDouble_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ltDouble *autocxx_gen_this) noexcept {
  void (*RDKit_ltDouble_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ltDouble *) = ::RDKit_ltDouble_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ltDouble_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_RDProps_clear_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDProps &autocxx_gen_this) noexcept {
  void (*RDKit_RDProps_clear_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDProps &) = ::RDKit_RDProps_clear_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDProps_clear_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
::RDKit::Dict const *RDKit$cxxbridge1$RDProps$getDict(::RDKit::RDProps const &self) noexcept {
  ::RDKit::Dict const &(::RDKit::RDProps::*getDict$)() const = &::RDKit::RDProps::getDict;
  return &(self.*getDict$)();
}

::RDKit::Dict *RDKit$cxxbridge1$RDProps$getDict1(::RDKit::RDProps &self) noexcept {
  ::RDKit::Dict &(::RDKit::RDProps::*getDict1$)() = &::RDKit::RDProps::getDict;
  return &(self.*getDict1$)();
}
} // extern "C"
} // namespace RDKit

extern "C" {
::std::vector<::std::string> *cxxbridge1$getPropList_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDProps const &autocxx_gen_this, bool includePrivate, bool includeComputed) noexcept {
  ::std::unique_ptr<::std::vector<::std::string>> (*getPropList_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDProps const &, bool, bool) = ::getPropList_autocxx_wrapper_0x7001b89d03cdd863;
  return getPropList_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, includePrivate, includeComputed).release();
}
} // extern "C"

namespace RDKit {
extern "C" {
bool RDKit$cxxbridge1$RDProps$hasProp(::RDKit::RDProps const &self, ::std::string const &key) noexcept {
  bool (::RDKit::RDProps::*hasProp$)(::std::string const &) const = &::RDKit::RDProps::hasProp;
  return (self.*hasProp$)(key);
}

void RDKit$cxxbridge1$RDProps$clearProp(::RDKit::RDProps const &self, ::std::string const &key) noexcept {
  void (::RDKit::RDProps::*clearProp$)(::std::string const &) const = &::RDKit::RDProps::clearProp;
  (self.*clearProp$)(key);
}

void RDKit$cxxbridge1$RDProps$clearComputedProps(::RDKit::RDProps const &self) noexcept {
  void (::RDKit::RDProps::*clearComputedProps$)() const = &::RDKit::RDProps::clearComputedProps;
  (self.*clearComputedProps$)();
}

void RDKit$cxxbridge1$RDProps$updateProps(::RDKit::RDProps &self, ::RDKit::RDProps const &source, bool preserveExisting) noexcept {
  void (::RDKit::RDProps::*updateProps$)(::RDKit::RDProps const &, bool) = &::RDKit::RDProps::updateProps;
  (self.*updateProps$)(source, preserveExisting);
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_RDProps_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDProps *autocxx_gen_this) noexcept {
  void (*RDKit_RDProps_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDProps *) = ::RDKit_RDProps_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDProps_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_RDProps_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDProps *autocxx_gen_this, ::RDKit::RDProps const &rhs) noexcept {
  void (*RDKit_RDProps_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDProps *, ::RDKit::RDProps const &) = ::RDKit_RDProps_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDProps_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, rhs);
}

void cxxbridge1$RDKit_RDProps_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDProps *autocxx_gen_this, ::RDKit::RDProps *o) noexcept {
  void (*RDKit_RDProps_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDProps *, ::RDKit::RDProps *) = ::RDKit_RDProps_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDProps_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, o);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$Atom$getAtomicNum(::RDKit::Atom const &self, ::c_int *return$) noexcept {
  ::c_int (::RDKit::Atom::*getAtomicNum$)() const = &::RDKit::Atom::getAtomicNum;
  new (return$) ::c_int((self.*getAtomicNum$)());
}

void RDKit$cxxbridge1$Atom$setAtomicNum(::RDKit::Atom &self, ::c_int *newNum) noexcept {
  void (::RDKit::Atom::*setAtomicNum$)(::c_int) = &::RDKit::Atom::setAtomicNum;
  (self.*setAtomicNum$)(::std::move(*newNum));
}
} // extern "C"
} // namespace RDKit

extern "C" {
::std::string *cxxbridge1$getSymbol_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const &autocxx_gen_this) noexcept {
  ::std::unique_ptr<::std::string> (*getSymbol_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const &) = ::getSymbol_autocxx_wrapper_0x7001b89d03cdd863;
  return getSymbol_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this).release();
}
} // extern "C"

namespace RDKit {
extern "C" {
bool RDKit$cxxbridge1$Atom$hasOwningMol(::RDKit::Atom const &self) noexcept {
  bool (::RDKit::Atom::*hasOwningMol$)() const = &::RDKit::Atom::hasOwningMol;
  return (self.*hasOwningMol$)();
}

void RDKit$cxxbridge1$Atom$getIdx(::RDKit::Atom const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getIdx$)() const = &::RDKit::Atom::getIdx;
  new (return$) ::c_uint((self.*getIdx$)());
}

void RDKit$cxxbridge1$Atom$setIdx(::RDKit::Atom &self, ::c_uint *index) noexcept {
  void (::RDKit::Atom::*setIdx$)(::c_uint) = &::RDKit::Atom::setIdx;
  (self.*setIdx$)(::std::move(*index));
}

void RDKit$cxxbridge1$Atom$getDegree(::RDKit::Atom const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getDegree$)() const = &::RDKit::Atom::getDegree;
  new (return$) ::c_uint((self.*getDegree$)());
}

void RDKit$cxxbridge1$Atom$getTotalDegree(::RDKit::Atom const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getTotalDegree$)() const = &::RDKit::Atom::getTotalDegree;
  new (return$) ::c_uint((self.*getTotalDegree$)());
}

void RDKit$cxxbridge1$Atom$getTotalNumHs(::RDKit::Atom const &self, bool includeNeighbors, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getTotalNumHs$)(bool) const = &::RDKit::Atom::getTotalNumHs;
  new (return$) ::c_uint((self.*getTotalNumHs$)(includeNeighbors));
}

void RDKit$cxxbridge1$Atom$getTotalValence(::RDKit::Atom const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getTotalValence$)() const = &::RDKit::Atom::getTotalValence;
  new (return$) ::c_uint((self.*getTotalValence$)());
}

void RDKit$cxxbridge1$Atom$getNumImplicitHs(::RDKit::Atom const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getNumImplicitHs$)() const = &::RDKit::Atom::getNumImplicitHs;
  new (return$) ::c_uint((self.*getNumImplicitHs$)());
}

void RDKit$cxxbridge1$Atom$getExplicitValence(::RDKit::Atom const &self, ::c_int *return$) noexcept {
  ::c_int (::RDKit::Atom::*getExplicitValence$)() const = &::RDKit::Atom::getExplicitValence;
  new (return$) ::c_int((self.*getExplicitValence$)());
}

void RDKit$cxxbridge1$Atom$getImplicitValence(::RDKit::Atom const &self, ::c_int *return$) noexcept {
  ::c_int (::RDKit::Atom::*getImplicitValence$)() const = &::RDKit::Atom::getImplicitValence;
  new (return$) ::c_int((self.*getImplicitValence$)());
}

void RDKit$cxxbridge1$Atom$getNumRadicalElectrons(::RDKit::Atom const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getNumRadicalElectrons$)() const = &::RDKit::Atom::getNumRadicalElectrons;
  new (return$) ::c_uint((self.*getNumRadicalElectrons$)());
}

void RDKit$cxxbridge1$Atom$setNumRadicalElectrons(::RDKit::Atom &self, ::c_uint *num) noexcept {
  void (::RDKit::Atom::*setNumRadicalElectrons$)(::c_uint) = &::RDKit::Atom::setNumRadicalElectrons;
  (self.*setNumRadicalElectrons$)(::std::move(*num));
}

void RDKit$cxxbridge1$Atom$getFormalCharge(::RDKit::Atom const &self, ::c_int *return$) noexcept {
  ::c_int (::RDKit::Atom::*getFormalCharge$)() const = &::RDKit::Atom::getFormalCharge;
  new (return$) ::c_int((self.*getFormalCharge$)());
}

void RDKit$cxxbridge1$Atom$setFormalCharge(::RDKit::Atom &self, ::c_int *what) noexcept {
  void (::RDKit::Atom::*setFormalCharge$)(::c_int) = &::RDKit::Atom::setFormalCharge;
  (self.*setFormalCharge$)(::std::move(*what));
}

void RDKit$cxxbridge1$Atom$setNoImplicit(::RDKit::Atom &self, bool what) noexcept {
  void (::RDKit::Atom::*setNoImplicit$)(bool) = &::RDKit::Atom::setNoImplicit;
  (self.*setNoImplicit$)(what);
}

bool RDKit$cxxbridge1$Atom$getNoImplicit(::RDKit::Atom const &self) noexcept {
  bool (::RDKit::Atom::*getNoImplicit$)() const = &::RDKit::Atom::getNoImplicit;
  return (self.*getNoImplicit$)();
}

void RDKit$cxxbridge1$Atom$setNumExplicitHs(::RDKit::Atom &self, ::c_uint *what) noexcept {
  void (::RDKit::Atom::*setNumExplicitHs$)(::c_uint) = &::RDKit::Atom::setNumExplicitHs;
  (self.*setNumExplicitHs$)(::std::move(*what));
}

void RDKit$cxxbridge1$Atom$getNumExplicitHs(::RDKit::Atom const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getNumExplicitHs$)() const = &::RDKit::Atom::getNumExplicitHs;
  new (return$) ::c_uint((self.*getNumExplicitHs$)());
}

void RDKit$cxxbridge1$Atom$setIsAromatic(::RDKit::Atom &self, bool what) noexcept {
  void (::RDKit::Atom::*setIsAromatic$)(bool) = &::RDKit::Atom::setIsAromatic;
  (self.*setIsAromatic$)(what);
}

bool RDKit$cxxbridge1$Atom$getIsAromatic(::RDKit::Atom const &self) noexcept {
  bool (::RDKit::Atom::*getIsAromatic$)() const = &::RDKit::Atom::getIsAromatic;
  return (self.*getIsAromatic$)();
}

double RDKit$cxxbridge1$Atom$getMass(::RDKit::Atom const &self) noexcept {
  double (::RDKit::Atom::*getMass$)() const = &::RDKit::Atom::getMass;
  return (self.*getMass$)();
}

void RDKit$cxxbridge1$Atom$setIsotope(::RDKit::Atom &self, ::c_uint *what) noexcept {
  void (::RDKit::Atom::*setIsotope$)(::c_uint) = &::RDKit::Atom::setIsotope;
  (self.*setIsotope$)(::std::move(*what));
}

void RDKit$cxxbridge1$Atom$getIsotope(::RDKit::Atom const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Atom::*getIsotope$)() const = &::RDKit::Atom::getIsotope;
  new (return$) ::c_uint((self.*getIsotope$)());
}

void RDKit$cxxbridge1$Atom$setChiralTag(::RDKit::Atom &self, ::RDKit::Atom::ChiralType *what) noexcept {
  void (::RDKit::Atom::*setChiralTag$)(::RDKit::Atom::ChiralType) = &::RDKit::Atom::setChiralTag;
  (self.*setChiralTag$)(::std::move(*what));
}

bool RDKit$cxxbridge1$Atom$invertChirality(::RDKit::Atom &self) noexcept {
  bool (::RDKit::Atom::*invertChirality$)() = &::RDKit::Atom::invertChirality;
  return (self.*invertChirality$)();
}

void RDKit$cxxbridge1$Atom$getChiralTag(::RDKit::Atom const &self, ::RDKit::Atom::ChiralType *return$) noexcept {
  ::RDKit::Atom::ChiralType (::RDKit::Atom::*getChiralTag$)() const = &::RDKit::Atom::getChiralTag;
  new (return$) ::RDKit::Atom::ChiralType((self.*getChiralTag$)());
}

void RDKit$cxxbridge1$Atom$setHybridization(::RDKit::Atom &self, ::RDKit::Atom::HybridizationType *what) noexcept {
  void (::RDKit::Atom::*setHybridization$)(::RDKit::Atom::HybridizationType) = &::RDKit::Atom::setHybridization;
  (self.*setHybridization$)(::std::move(*what));
}

void RDKit$cxxbridge1$Atom$getHybridization(::RDKit::Atom const &self, ::RDKit::Atom::HybridizationType *return$) noexcept {
  ::RDKit::Atom::HybridizationType (::RDKit::Atom::*getHybridization$)() const = &::RDKit::Atom::getHybridization;
  new (return$) ::RDKit::Atom::HybridizationType((self.*getHybridization$)());
}

void RDKit$cxxbridge1$Atom$getPerturbationOrder(::RDKit::Atom const &self, ::RDKit::INT_LIST const &probe, ::c_int *return$) noexcept {
  ::c_int (::RDKit::Atom::*getPerturbationOrder$)(::RDKit::INT_LIST const &) const = &::RDKit::Atom::getPerturbationOrder;
  new (return$) ::c_int((self.*getPerturbationOrder$)(probe));
}

void RDKit$cxxbridge1$Atom$updatePropertyCache(::RDKit::Atom &self, bool strict) noexcept {
  void (::RDKit::Atom::*updatePropertyCache$)(bool) = &::RDKit::Atom::updatePropertyCache;
  (self.*updatePropertyCache$)(strict);
}

bool RDKit$cxxbridge1$Atom$needsUpdatePropertyCache(::RDKit::Atom const &self) noexcept {
  bool (::RDKit::Atom::*needsUpdatePropertyCache$)() const = &::RDKit::Atom::needsUpdatePropertyCache;
  return (self.*needsUpdatePropertyCache$)();
}

void RDKit$cxxbridge1$Atom$calcExplicitValence(::RDKit::Atom &self, bool strict, ::c_int *return$) noexcept {
  ::c_int (::RDKit::Atom::*calcExplicitValence$)(bool) = &::RDKit::Atom::calcExplicitValence;
  new (return$) ::c_int((self.*calcExplicitValence$)(strict));
}

void RDKit$cxxbridge1$Atom$calcImplicitValence(::RDKit::Atom &self, bool strict, ::c_int *return$) noexcept {
  ::c_int (::RDKit::Atom::*calcImplicitValence$)(bool) = &::RDKit::Atom::calcImplicitValence;
  new (return$) ::c_int((self.*calcImplicitValence$)(strict));
}

::RDKit::AtomMonomerInfo *RDKit$cxxbridge1$Atom$getMonomerInfo(::RDKit::Atom &self) noexcept {
  ::RDKit::AtomMonomerInfo *(::RDKit::Atom::*getMonomerInfo$)() = &::RDKit::Atom::getMonomerInfo;
  return (self.*getMonomerInfo$)();
}

::RDKit::AtomMonomerInfo const *RDKit$cxxbridge1$Atom$getMonomerInfo1(::RDKit::Atom const &self) noexcept {
  ::RDKit::AtomMonomerInfo const *(::RDKit::Atom::*getMonomerInfo1$)() const = &::RDKit::Atom::getMonomerInfo;
  return (self.*getMonomerInfo1$)();
}

void RDKit$cxxbridge1$Atom$setMonomerInfo(::RDKit::Atom &self, ::RDKit::AtomMonomerInfo *info) noexcept {
  void (::RDKit::Atom::*setMonomerInfo$)(::RDKit::AtomMonomerInfo *) = &::RDKit::Atom::setMonomerInfo;
  (self.*setMonomerInfo$)(info);
}

void RDKit$cxxbridge1$Atom$setAtomMapNum(::RDKit::Atom &self, ::c_int *mapno, bool strict) noexcept {
  void (::RDKit::Atom::*setAtomMapNum$)(::c_int, bool) = &::RDKit::Atom::setAtomMapNum;
  (self.*setAtomMapNum$)(::std::move(*mapno), strict);
}

void RDKit$cxxbridge1$Atom$getAtomMapNum(::RDKit::Atom const &self, ::c_int *return$) noexcept {
  ::c_int (::RDKit::Atom::*getAtomMapNum$)() const = &::RDKit::Atom::getAtomMapNum;
  new (return$) ::c_int((self.*getAtomMapNum$)());
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_Atom_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom *autocxx_gen_this) noexcept {
  void (*RDKit_Atom_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom *) = ::RDKit_Atom_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Atom_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Atom_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom *autocxx_gen_this, ::c_uint *num) noexcept {
  void (*RDKit_Atom_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom *, ::c_uint) = ::RDKit_Atom_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Atom_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*num));
}

void cxxbridge1$RDKit_Atom_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom *autocxx_gen_this, ::std::string const &what) noexcept {
  void (*RDKit_Atom_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom *, ::std::string const &) = ::RDKit_Atom_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Atom_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, what);
}

void cxxbridge1$RDKit_Atom_new3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom *autocxx_gen_this, ::RDKit::Atom const &other) noexcept {
  void (*RDKit_Atom_new3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom *, ::RDKit::Atom const &) = ::RDKit_Atom_new3_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Atom_new3_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_Atom_new4_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom *autocxx_gen_this, ::RDKit::Atom *other) noexcept {
  void (*RDKit_Atom_new4_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom *, ::RDKit::Atom *) = ::RDKit_Atom_new4_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Atom_new4_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$Atom_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom *autocxx_gen_this) noexcept {
  void (*Atom_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom *) = ::Atom_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  Atom_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::RDKit::Atom *cxxbridge1$copy_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const &autocxx_gen_this) noexcept {
  ::RDKit::Atom *(*copy_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const &) = ::copy_autocxx_wrapper_0x7001b89d03cdd863;
  return copy_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

bool cxxbridge1$hasQuery_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const &autocxx_gen_this) noexcept {
  bool (*hasQuery_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const &) = ::hasQuery_autocxx_wrapper_0x7001b89d03cdd863;
  return hasQuery_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::std::string *cxxbridge1$getQueryType_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const &autocxx_gen_this) noexcept {
  ::std::unique_ptr<::std::string> (*getQueryType_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const &) = ::getQueryType_autocxx_wrapper_0x7001b89d03cdd863;
  return getQueryType_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this).release();
}

void cxxbridge1$setQuery_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom &autocxx_gen_this, ::std::uint8_t *what) noexcept {
  void (*setQuery_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom &, ::std::uint8_t *) = ::setQuery_autocxx_wrapper_0x7001b89d03cdd863;
  setQuery_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, what);
}

::std::uint8_t *cxxbridge1$getQuery_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const &autocxx_gen_this) noexcept {
  ::std::uint8_t *(*getQuery_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const &) = ::getQuery_autocxx_wrapper_0x7001b89d03cdd863;
  return getQuery_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$expandQuery_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom &autocxx_gen_this, ::std::uint8_t *what, ::Queries::CompositeQueryType *how, bool maintainOrder) noexcept {
  void (*expandQuery_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom &, ::std::uint8_t *, ::Queries::CompositeQueryType, bool) = ::expandQuery_autocxx_wrapper_0x7001b89d03cdd863;
  expandQuery_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, what, ::std::move(*how), maintainOrder);
}

bool cxxbridge1$Match_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const &autocxx_gen_this, ::RDKit::Atom const *what) noexcept {
  bool (*Match_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const &, ::RDKit::Atom const *) = ::Match_autocxx_wrapper_0x7001b89d03cdd863;
  return Match_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, what);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$setAtomRLabel(::RDKit::Atom *atm, ::c_int *rlabel) noexcept {
  void (*setAtomRLabel$)(::RDKit::Atom *, ::c_int) = ::RDKit::setAtomRLabel;
  setAtomRLabel$(atm, ::std::move(*rlabel));
}

void RDKit$cxxbridge1$getAtomRLabel(::RDKit::Atom const *atm, ::c_int *return$) noexcept {
  ::c_int (*getAtomRLabel$)(::RDKit::Atom const *) = ::RDKit::getAtomRLabel;
  new (return$) ::c_int(getAtomRLabel$(atm));
}

void RDKit$cxxbridge1$setAtomAlias(::RDKit::Atom *atom, ::std::string const &alias) noexcept {
  void (*setAtomAlias$)(::RDKit::Atom *, ::std::string const &) = ::RDKit::setAtomAlias;
  setAtomAlias$(atom, alias);
}
} // extern "C"
} // namespace RDKit

extern "C" {
::std::string *cxxbridge1$getAtomAlias_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const *atom) noexcept {
  ::std::unique_ptr<::std::string> (*getAtomAlias_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const *) = ::getAtomAlias_autocxx_wrapper_0x7001b89d03cdd863;
  return getAtomAlias_autocxx_wrapper_0x7001b89d03cdd863$(atom).release();
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$setAtomValue(::RDKit::Atom *atom, ::std::string const &value) noexcept {
  void (*setAtomValue$)(::RDKit::Atom *, ::std::string const &) = ::RDKit::setAtomValue;
  setAtomValue$(atom, value);
}
} // extern "C"
} // namespace RDKit

extern "C" {
::std::string *cxxbridge1$getAtomValue_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const *atom) noexcept {
  ::std::unique_ptr<::std::string> (*getAtomValue_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const *) = ::getAtomValue_autocxx_wrapper_0x7001b89d03cdd863;
  return getAtomValue_autocxx_wrapper_0x7001b89d03cdd863$(atom).release();
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$setSupplementalSmilesLabel(::RDKit::Atom *atom, ::std::string const &label) noexcept {
  void (*setSupplementalSmilesLabel$)(::RDKit::Atom *, ::std::string const &) = ::RDKit::setSupplementalSmilesLabel;
  setSupplementalSmilesLabel$(atom, label);
}
} // extern "C"
} // namespace RDKit

extern "C" {
::std::string *cxxbridge1$getSupplementalSmilesLabel_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Atom const *atom) noexcept {
  ::std::unique_ptr<::std::string> (*getSupplementalSmilesLabel_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Atom const *) = ::getSupplementalSmilesLabel_autocxx_wrapper_0x7001b89d03cdd863;
  return getSupplementalSmilesLabel_autocxx_wrapper_0x7001b89d03cdd863$(atom).release();
}
} // extern "C"

namespace RDKit {
extern "C" {
bool RDKit$cxxbridge1$isEarlyAtom(::c_int *atomicNum) noexcept {
  bool (*isEarlyAtom$)(::c_int) = ::RDKit::isEarlyAtom;
  return isEarlyAtom$(::std::move(*atomicNum));
}

bool RDKit$cxxbridge1$isAromaticAtom(::RDKit::Atom const &atom) noexcept {
  bool (*isAromaticAtom$)(::RDKit::Atom const &) = ::RDKit::isAromaticAtom;
  return isAromaticAtom$(atom);
}

void RDKit$cxxbridge1$Bond$getBondType(::RDKit::Bond const &self, ::RDKit::Bond::BondType *return$) noexcept {
  ::RDKit::Bond::BondType (::RDKit::Bond::*getBondType$)() const = &::RDKit::Bond::getBondType;
  new (return$) ::RDKit::Bond::BondType((self.*getBondType$)());
}

void RDKit$cxxbridge1$Bond$setBondType(::RDKit::Bond &self, ::RDKit::Bond::BondType *bT) noexcept {
  void (::RDKit::Bond::*setBondType$)(::RDKit::Bond::BondType) = &::RDKit::Bond::setBondType;
  (self.*setBondType$)(::std::move(*bT));
}

double RDKit$cxxbridge1$Bond$getBondTypeAsDouble(::RDKit::Bond const &self) noexcept {
  double (::RDKit::Bond::*getBondTypeAsDouble$)() const = &::RDKit::Bond::getBondTypeAsDouble;
  return (self.*getBondTypeAsDouble$)();
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_Bond_setIsAromatic_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond &autocxx_gen_this, bool what) noexcept {
  void (*RDKit_Bond_setIsAromatic_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond &, bool) = ::RDKit_Bond_setIsAromatic_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_setIsAromatic_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, what);
}

bool cxxbridge1$RDKit_Bond_getIsAromatic_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this) noexcept {
  bool (*RDKit_Bond_getIsAromatic_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &) = ::RDKit_Bond_getIsAromatic_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_Bond_getIsAromatic_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$Bond$setIsConjugated(::RDKit::Bond &self, bool what) noexcept {
  void (::RDKit::Bond::*setIsConjugated$)(bool) = &::RDKit::Bond::setIsConjugated;
  (self.*setIsConjugated$)(what);
}

bool RDKit$cxxbridge1$Bond$getIsConjugated(::RDKit::Bond const &self) noexcept {
  bool (::RDKit::Bond::*getIsConjugated$)() const = &::RDKit::Bond::getIsConjugated;
  return (self.*getIsConjugated$)();
}
} // extern "C"
} // namespace RDKit

extern "C" {
bool cxxbridge1$RDKit_Bond_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this) noexcept {
  bool (*RDKit_Bond_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &) = ::RDKit_Bond_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_Bond_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Bond_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond &autocxx_gen_this, ::RDKit::ROMol *other) noexcept {
  void (*RDKit_Bond_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond &, ::RDKit::ROMol *) = ::RDKit_Bond_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_Bond_setOwningMol1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond &autocxx_gen_this, ::RDKit::ROMol &other) noexcept {
  void (*RDKit_Bond_setOwningMol1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond &, ::RDKit::ROMol &) = ::RDKit_Bond_setOwningMol1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_setOwningMol1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_Bond_getIdx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this, ::c_uint *return$) noexcept {
  ::c_uint (*RDKit_Bond_getIdx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &) = ::RDKit_Bond_getIdx_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_uint(RDKit_Bond_getIdx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this));
}

void cxxbridge1$RDKit_Bond_setIdx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond &autocxx_gen_this, ::c_uint *index) noexcept {
  void (*RDKit_Bond_setIdx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond &, ::c_uint) = ::RDKit_Bond_setIdx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_setIdx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*index));
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$Bond$getBeginAtomIdx(::RDKit::Bond const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Bond::*getBeginAtomIdx$)() const = &::RDKit::Bond::getBeginAtomIdx;
  new (return$) ::c_uint((self.*getBeginAtomIdx$)());
}

void RDKit$cxxbridge1$Bond$getEndAtomIdx(::RDKit::Bond const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Bond::*getEndAtomIdx$)() const = &::RDKit::Bond::getEndAtomIdx;
  new (return$) ::c_uint((self.*getEndAtomIdx$)());
}

void RDKit$cxxbridge1$Bond$getOtherAtomIdx(::RDKit::Bond const &self, ::c_uint *thisIdx, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Bond::*getOtherAtomIdx$)(::c_uint) const = &::RDKit::Bond::getOtherAtomIdx;
  new (return$) ::c_uint((self.*getOtherAtomIdx$)(::std::move(*thisIdx)));
}

void RDKit$cxxbridge1$Bond$setBeginAtomIdx(::RDKit::Bond &self, ::c_uint *what) noexcept {
  void (::RDKit::Bond::*setBeginAtomIdx$)(::c_uint) = &::RDKit::Bond::setBeginAtomIdx;
  (self.*setBeginAtomIdx$)(::std::move(*what));
}

void RDKit$cxxbridge1$Bond$setEndAtomIdx(::RDKit::Bond &self, ::c_uint *what) noexcept {
  void (::RDKit::Bond::*setEndAtomIdx$)(::c_uint) = &::RDKit::Bond::setEndAtomIdx;
  (self.*setEndAtomIdx$)(::std::move(*what));
}

void RDKit$cxxbridge1$Bond$setBeginAtom(::RDKit::Bond &self, ::RDKit::Atom *at) noexcept {
  void (::RDKit::Bond::*setBeginAtom$)(::RDKit::Atom *) = &::RDKit::Bond::setBeginAtom;
  (self.*setBeginAtom$)(at);
}

void RDKit$cxxbridge1$Bond$setEndAtom(::RDKit::Bond &self, ::RDKit::Atom *at) noexcept {
  void (::RDKit::Bond::*setEndAtom$)(::RDKit::Atom *) = &::RDKit::Bond::setEndAtom;
  (self.*setEndAtom$)(at);
}

::RDKit::Atom *RDKit$cxxbridge1$Bond$getBeginAtom(::RDKit::Bond const &self) noexcept {
  ::RDKit::Atom *(::RDKit::Bond::*getBeginAtom$)() const = &::RDKit::Bond::getBeginAtom;
  return (self.*getBeginAtom$)();
}

::RDKit::Atom *RDKit$cxxbridge1$Bond$getEndAtom(::RDKit::Bond const &self) noexcept {
  ::RDKit::Atom *(::RDKit::Bond::*getEndAtom$)() const = &::RDKit::Bond::getEndAtom;
  return (self.*getEndAtom$)();
}

::RDKit::Atom *RDKit$cxxbridge1$Bond$getOtherAtom(::RDKit::Bond const &self, ::RDKit::Atom const *what) noexcept {
  ::RDKit::Atom *(::RDKit::Bond::*getOtherAtom$)(::RDKit::Atom const *) const = &::RDKit::Bond::getOtherAtom;
  return (self.*getOtherAtom$)(what);
}

void RDKit$cxxbridge1$Bond$setBondDir(::RDKit::Bond &self, ::RDKit::Bond::BondDir *what) noexcept {
  void (::RDKit::Bond::*setBondDir$)(::RDKit::Bond::BondDir) = &::RDKit::Bond::setBondDir;
  (self.*setBondDir$)(::std::move(*what));
}

void RDKit$cxxbridge1$Bond$getBondDir(::RDKit::Bond const &self, ::RDKit::Bond::BondDir *return$) noexcept {
  ::RDKit::Bond::BondDir (::RDKit::Bond::*getBondDir$)() const = &::RDKit::Bond::getBondDir;
  new (return$) ::RDKit::Bond::BondDir((self.*getBondDir$)());
}

void RDKit$cxxbridge1$Bond$setStereo(::RDKit::Bond &self, ::RDKit::Bond::BondStereo *what) noexcept {
  void (::RDKit::Bond::*setStereo$)(::RDKit::Bond::BondStereo) = &::RDKit::Bond::setStereo;
  (self.*setStereo$)(::std::move(*what));
}

void RDKit$cxxbridge1$Bond$getStereo(::RDKit::Bond const &self, ::RDKit::Bond::BondStereo *return$) noexcept {
  ::RDKit::Bond::BondStereo (::RDKit::Bond::*getStereo$)() const = &::RDKit::Bond::getStereo;
  new (return$) ::RDKit::Bond::BondStereo((self.*getStereo$)());
}

void RDKit$cxxbridge1$Bond$setStereoAtoms(::RDKit::Bond &self, ::c_uint *bgnIdx, ::c_uint *endIdx) noexcept {
  void (::RDKit::Bond::*setStereoAtoms$)(::c_uint, ::c_uint) = &::RDKit::Bond::setStereoAtoms;
  (self.*setStereoAtoms$)(::std::move(*bgnIdx), ::std::move(*endIdx));
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_Bond_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond &autocxx_gen_this, bool strict) noexcept {
  void (*RDKit_Bond_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond &, bool) = ::RDKit_Bond_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, strict);
}

void cxxbridge1$RDKit_Bond_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond *autocxx_gen_this) noexcept {
  void (*RDKit_Bond_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond *) = ::RDKit_Bond_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Bond_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond *autocxx_gen_this, ::RDKit::Bond::BondType *bT) noexcept {
  void (*RDKit_Bond_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond *, ::RDKit::Bond::BondType) = ::RDKit_Bond_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*bT));
}

void cxxbridge1$RDKit_Bond_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond *autocxx_gen_this, ::RDKit::Bond const &other) noexcept {
  void (*RDKit_Bond_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond *, ::RDKit::Bond const &) = ::RDKit_Bond_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_Bond_new3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond *autocxx_gen_this, ::RDKit::Bond *o) noexcept {
  void (*RDKit_Bond_new3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond *, ::RDKit::Bond *) = ::RDKit_Bond_new3_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_new3_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, o);
}

void cxxbridge1$Bond_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond *autocxx_gen_this) noexcept {
  void (*Bond_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond *) = ::Bond_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  Bond_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::RDKit::Bond *cxxbridge1$RDKit_Bond_copy_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this) noexcept {
  ::RDKit::Bond *(*RDKit_Bond_copy_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &) = ::RDKit_Bond_copy_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_Bond_copy_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

double cxxbridge1$getValenceContrib_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this, ::RDKit::Atom const *at) noexcept {
  double (*getValenceContrib_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &, ::RDKit::Atom const *) = ::getValenceContrib_autocxx_wrapper_0x7001b89d03cdd863;
  return getValenceContrib_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, at);
}

bool cxxbridge1$RDKit_Bond_hasQuery_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this) noexcept {
  bool (*RDKit_Bond_hasQuery_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &) = ::RDKit_Bond_hasQuery_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_Bond_hasQuery_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Bond_setQuery_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond &autocxx_gen_this, ::std::uint8_t *what) noexcept {
  void (*RDKit_Bond_setQuery_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond &, ::std::uint8_t *) = ::RDKit_Bond_setQuery_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_setQuery_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, what);
}

::std::uint8_t *cxxbridge1$RDKit_Bond_getQuery_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this) noexcept {
  ::std::uint8_t *(*RDKit_Bond_getQuery_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &) = ::RDKit_Bond_getQuery_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_Bond_getQuery_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Bond_expandQuery_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond &autocxx_gen_this, ::std::uint8_t *what, ::Queries::CompositeQueryType *how, bool maintainOrder) noexcept {
  void (*RDKit_Bond_expandQuery_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond &, ::std::uint8_t *, ::Queries::CompositeQueryType, bool) = ::RDKit_Bond_expandQuery_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Bond_expandQuery_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, what, ::std::move(*how), maintainOrder);
}

bool cxxbridge1$RDKit_Bond_Match_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Bond const &autocxx_gen_this, ::RDKit::Bond const *what) noexcept {
  bool (*RDKit_Bond_Match_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Bond const &, ::RDKit::Bond const *) = ::RDKit_Bond_Match_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_Bond_Match_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, what);
}
} // extern "C"

namespace RDKit {
extern "C" {
::std::uint8_t RDKit$cxxbridge1$getTwiceBondType(::RDKit::Bond const &b) noexcept {
  ::std::uint8_t (*getTwiceBondType$)(::RDKit::Bond const &) = ::RDKit::getTwiceBondType;
  return getTwiceBondType$(b);
}

bool RDKit$cxxbridge1$feq(double v1, double v2, double tol) noexcept {
  bool (*feq$)(double, double, double) = ::RDKit::feq;
  return feq$(v1, v2, tol);
}

double RDKit$cxxbridge1$getRandomVal(::c_int *seed) noexcept {
  double (*getRandomVal$)(::c_int) = ::RDKit::getRandomVal;
  return getRandomVal$(::std::move(*seed));
}
} // extern "C"
} // namespace RDKit

extern "C" {
::std::string *cxxbridge1$augmentTagName_autocxx_wrapper_0x7001b89d03cdd863(::std::string const &tag) noexcept {
  ::std::unique_ptr<::std::string> (*augmentTagName_autocxx_wrapper_0x7001b89d03cdd863$)(::std::string const &) = ::augmentTagName_autocxx_wrapper_0x7001b89d03cdd863;
  return augmentTagName_autocxx_wrapper_0x7001b89d03cdd863$(tag).release();
}

void cxxbridge1$RDKit_ConformerException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ConformerException *autocxx_gen_this, char const *msg) noexcept {
  void (*RDKit_ConformerException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ConformerException *, char const *) = ::RDKit_ConformerException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ConformerException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, msg);
}

void cxxbridge1$RDKit_ConformerException_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ConformerException *autocxx_gen_this, ::std::string *msg) noexcept {
  void (*RDKit_ConformerException_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ConformerException *, ::std::unique_ptr<::std::string>) = ::RDKit_ConformerException_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ConformerException_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::unique_ptr<::std::string>(msg));
}

char const *cxxbridge1$RDKit_ConformerException_what_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ConformerException const &autocxx_gen_this) noexcept {
  char const *(*RDKit_ConformerException_what_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ConformerException const &) = ::RDKit_ConformerException_what_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_ConformerException_what_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$ConformerException_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ConformerException *autocxx_gen_this) noexcept {
  void (*ConformerException_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ConformerException *) = ::ConformerException_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  ConformerException_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$Conformer$resize(::RDKit::Conformer &self, ::c_uint *size) noexcept {
  void (::RDKit::Conformer::*resize$)(::c_uint) = &::RDKit::Conformer::resize;
  (self.*resize$)(::std::move(*size));
}

void RDKit$cxxbridge1$Conformer$reserve(::RDKit::Conformer &self, ::c_uint *size) noexcept {
  void (::RDKit::Conformer::*reserve$)(::c_uint) = &::RDKit::Conformer::reserve;
  (self.*reserve$)(::std::move(*size));
}
} // extern "C"
} // namespace RDKit

extern "C" {
bool cxxbridge1$RDKit_Conformer_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Conformer const &autocxx_gen_this) noexcept {
  bool (*RDKit_Conformer_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Conformer const &) = ::RDKit_Conformer_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_Conformer_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
::std::vector<::RDGeom::Point3D> const *RDKit$cxxbridge1$Conformer$getPositions(::RDKit::Conformer const &self) noexcept {
  ::std::vector<::RDGeom::Point3D> const &(::RDKit::Conformer::*getPositions$)() const = &::RDKit::Conformer::getPositions;
  return &(self.*getPositions$)();
}

::std::vector<::RDGeom::Point3D> *RDKit$cxxbridge1$Conformer$getPositions1(::RDKit::Conformer &self) noexcept {
  ::std::vector<::RDGeom::Point3D> &(::RDKit::Conformer::*getPositions1$)() = &::RDKit::Conformer::getPositions;
  return &(self.*getPositions1$)();
}

::RDGeom::Point3D const *RDKit$cxxbridge1$Conformer$getAtomPos(::RDKit::Conformer const &self, ::c_uint *atomId) noexcept {
  ::RDGeom::Point3D const &(::RDKit::Conformer::*getAtomPos$)(::c_uint) const = &::RDKit::Conformer::getAtomPos;
  return &(self.*getAtomPos$)(::std::move(*atomId));
}

::RDGeom::Point3D *RDKit$cxxbridge1$Conformer$getAtomPos1(::RDKit::Conformer &self, ::c_uint *atomId) noexcept {
  ::RDGeom::Point3D &(::RDKit::Conformer::*getAtomPos1$)(::c_uint) = &::RDKit::Conformer::getAtomPos;
  return &(self.*getAtomPos1$)(::std::move(*atomId));
}

void RDKit$cxxbridge1$Conformer$setAtomPos(::RDKit::Conformer &self, ::c_uint *atomId, ::RDGeom::Point3D const &position) noexcept {
  void (::RDKit::Conformer::*setAtomPos$)(::c_uint, ::RDGeom::Point3D const &) = &::RDKit::Conformer::setAtomPos;
  (self.*setAtomPos$)(::std::move(*atomId), position);
}

void RDKit$cxxbridge1$Conformer$getId(::RDKit::Conformer const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Conformer::*getId$)() const = &::RDKit::Conformer::getId;
  new (return$) ::c_uint((self.*getId$)());
}

void RDKit$cxxbridge1$Conformer$setId(::RDKit::Conformer &self, ::c_uint *id) noexcept {
  void (::RDKit::Conformer::*setId$)(::c_uint) = &::RDKit::Conformer::setId;
  (self.*setId$)(::std::move(*id));
}

void RDKit$cxxbridge1$Conformer$getNumAtoms(::RDKit::Conformer const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::Conformer::*getNumAtoms$)() const = &::RDKit::Conformer::getNumAtoms;
  new (return$) ::c_uint((self.*getNumAtoms$)());
}

bool RDKit$cxxbridge1$Conformer$is3D(::RDKit::Conformer const &self) noexcept {
  bool (::RDKit::Conformer::*is3D$)() const = &::RDKit::Conformer::is3D;
  return (self.*is3D$)();
}

void RDKit$cxxbridge1$Conformer$set3D(::RDKit::Conformer &self, bool v) noexcept {
  void (::RDKit::Conformer::*set3D$)(bool) = &::RDKit::Conformer::set3D;
  (self.*set3D$)(v);
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_Conformer_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Conformer *autocxx_gen_this) noexcept {
  void (*RDKit_Conformer_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Conformer *) = ::RDKit_Conformer_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Conformer_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Conformer_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Conformer *autocxx_gen_this, ::c_uint *numAtoms) noexcept {
  void (*RDKit_Conformer_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Conformer *, ::c_uint) = ::RDKit_Conformer_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Conformer_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*numAtoms));
}

void cxxbridge1$RDKit_Conformer_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Conformer *autocxx_gen_this, ::RDKit::Conformer const &other) noexcept {
  void (*RDKit_Conformer_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Conformer *, ::RDKit::Conformer const &) = ::RDKit_Conformer_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Conformer_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_Conformer_new3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Conformer *autocxx_gen_this, ::RDKit::Conformer *o) noexcept {
  void (*RDKit_Conformer_new3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Conformer *, ::RDKit::Conformer *) = ::RDKit_Conformer_new3_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Conformer_new3_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, o);
}

void cxxbridge1$Conformer_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Conformer *autocxx_gen_this) noexcept {
  void (*Conformer_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Conformer *) = ::Conformer_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  Conformer_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
bool RDKit$cxxbridge1$hasNonZeroZCoords(::RDKit::Conformer const &conf) noexcept {
  bool (*hasNonZeroZCoords$)(::RDKit::Conformer const &) = ::RDKit::hasNonZeroZCoords;
  return hasNonZeroZCoords$(conf);
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_SubstanceGroupException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroupException *autocxx_gen_this, char const *msg) noexcept {
  void (*RDKit_SubstanceGroupException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroupException *, char const *) = ::RDKit_SubstanceGroupException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroupException_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, msg);
}

void cxxbridge1$RDKit_SubstanceGroupException_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroupException *autocxx_gen_this, ::std::string const &msg) noexcept {
  void (*RDKit_SubstanceGroupException_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroupException *, ::std::string const &) = ::RDKit_SubstanceGroupException_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroupException_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, msg);
}

bool cxxbridge1$RDKit_SubstanceGroup_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup const &autocxx_gen_this) noexcept {
  bool (*RDKit_SubstanceGroup_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup const &) = ::RDKit_SubstanceGroup_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_SubstanceGroup_hasOwningMol_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
bool RDKit$cxxbridge1$SubstanceGroup$getIsValid(::RDKit::SubstanceGroup const &self) noexcept {
  bool (::RDKit::SubstanceGroup::*getIsValid$)() const = &::RDKit::SubstanceGroup::getIsValid;
  return (self.*getIsValid$)();
}

void RDKit$cxxbridge1$SubstanceGroup$setIsValid(::RDKit::SubstanceGroup &self, bool isValid) noexcept {
  void (::RDKit::SubstanceGroup::*setIsValid$)(bool) = &::RDKit::SubstanceGroup::setIsValid;
  (self.*setIsValid$)(isValid);
}

void RDKit$cxxbridge1$SubstanceGroup$getIndexInMol(::RDKit::SubstanceGroup const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::SubstanceGroup::*getIndexInMol$)() const = &::RDKit::SubstanceGroup::getIndexInMol;
  new (return$) ::c_uint((self.*getIndexInMol$)());
}

void RDKit$cxxbridge1$SubstanceGroup$addAtomWithIdx(::RDKit::SubstanceGroup &self, ::c_uint *idx) noexcept {
  void (::RDKit::SubstanceGroup::*addAtomWithIdx$)(::c_uint) = &::RDKit::SubstanceGroup::addAtomWithIdx;
  (self.*addAtomWithIdx$)(::std::move(*idx));
}

void RDKit$cxxbridge1$SubstanceGroup$addParentAtomWithIdx(::RDKit::SubstanceGroup &self, ::c_uint *idx) noexcept {
  void (::RDKit::SubstanceGroup::*addParentAtomWithIdx$)(::c_uint) = &::RDKit::SubstanceGroup::addParentAtomWithIdx;
  (self.*addParentAtomWithIdx$)(::std::move(*idx));
}

void RDKit$cxxbridge1$SubstanceGroup$addBondWithIdx(::RDKit::SubstanceGroup &self, ::c_uint *idx) noexcept {
  void (::RDKit::SubstanceGroup::*addBondWithIdx$)(::c_uint) = &::RDKit::SubstanceGroup::addBondWithIdx;
  (self.*addBondWithIdx$)(::std::move(*idx));
}

void RDKit$cxxbridge1$SubstanceGroup$addAtomWithBookmark(::RDKit::SubstanceGroup &self, ::c_int *mark) noexcept {
  void (::RDKit::SubstanceGroup::*addAtomWithBookmark$)(::c_int) = &::RDKit::SubstanceGroup::addAtomWithBookmark;
  (self.*addAtomWithBookmark$)(::std::move(*mark));
}

void RDKit$cxxbridge1$SubstanceGroup$addParentAtomWithBookmark(::RDKit::SubstanceGroup &self, ::c_int *mark) noexcept {
  void (::RDKit::SubstanceGroup::*addParentAtomWithBookmark$)(::c_int) = &::RDKit::SubstanceGroup::addParentAtomWithBookmark;
  (self.*addParentAtomWithBookmark$)(::std::move(*mark));
}

void RDKit$cxxbridge1$SubstanceGroup$addBondWithBookmark(::RDKit::SubstanceGroup &self, ::c_int *mark) noexcept {
  void (::RDKit::SubstanceGroup::*addBondWithBookmark$)(::c_int) = &::RDKit::SubstanceGroup::addBondWithBookmark;
  (self.*addBondWithBookmark$)(::std::move(*mark));
}

void RDKit$cxxbridge1$SubstanceGroup$removeAtomWithIdx(::RDKit::SubstanceGroup &self, ::c_uint *idx) noexcept {
  void (::RDKit::SubstanceGroup::*removeAtomWithIdx$)(::c_uint) = &::RDKit::SubstanceGroup::removeAtomWithIdx;
  (self.*removeAtomWithIdx$)(::std::move(*idx));
}

void RDKit$cxxbridge1$SubstanceGroup$removeParentAtomWithIdx(::RDKit::SubstanceGroup &self, ::c_uint *idx) noexcept {
  void (::RDKit::SubstanceGroup::*removeParentAtomWithIdx$)(::c_uint) = &::RDKit::SubstanceGroup::removeParentAtomWithIdx;
  (self.*removeParentAtomWithIdx$)(::std::move(*idx));
}

void RDKit$cxxbridge1$SubstanceGroup$removeBondWithIdx(::RDKit::SubstanceGroup &self, ::c_uint *idx) noexcept {
  void (::RDKit::SubstanceGroup::*removeBondWithIdx$)(::c_uint) = &::RDKit::SubstanceGroup::removeBondWithIdx;
  (self.*removeBondWithIdx$)(::std::move(*idx));
}

void RDKit$cxxbridge1$SubstanceGroup$addBracket(::RDKit::SubstanceGroup &self, ::std::array<::std::uint64_t, 12> const &bracket) noexcept {
  void (::RDKit::SubstanceGroup::*addBracket$)(::std::array<::std::uint64_t, 12> const &) = &::RDKit::SubstanceGroup::addBracket;
  (self.*addBracket$)(bracket);
}

void RDKit$cxxbridge1$SubstanceGroup$addCState(::RDKit::SubstanceGroup &self, ::c_uint *bondIdx, ::RDGeom::Point3D const &vector) noexcept {
  void (::RDKit::SubstanceGroup::*addCState$)(::c_uint, ::RDGeom::Point3D const &) = &::RDKit::SubstanceGroup::addCState;
  (self.*addCState$)(::std::move(*bondIdx), vector);
}

void RDKit$cxxbridge1$SubstanceGroup$addAttachPoint(::RDKit::SubstanceGroup &self, ::c_uint *aIdx, ::c_int *lvIdx, ::std::string const &idStr) noexcept {
  void (::RDKit::SubstanceGroup::*addAttachPoint$)(::c_uint, ::c_int, ::std::string const &) = &::RDKit::SubstanceGroup::addAttachPoint;
  (self.*addAttachPoint$)(::std::move(*aIdx), ::std::move(*lvIdx), idStr);
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_SubstanceGroup_getBondType_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup const &autocxx_gen_this, ::c_uint *bondIdx, ::RDKit::SubstanceGroup::BondType *return$) noexcept {
  ::RDKit::SubstanceGroup::BondType (*RDKit_SubstanceGroup_getBondType_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup const &, ::c_uint) = ::RDKit_SubstanceGroup_getBondType_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::RDKit::SubstanceGroup::BondType(RDKit_SubstanceGroup_getBondType_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, ::std::move(*bondIdx)));
}
} // extern "C"

namespace RDKit {
extern "C" {
::std::vector<::RDKit::SubstanceGroup::CState> const *RDKit$cxxbridge1$SubstanceGroup$getCStates(::RDKit::SubstanceGroup const &self) noexcept {
  ::std::vector<::RDKit::SubstanceGroup::CState> const &(::RDKit::SubstanceGroup::*getCStates$)() const = &::RDKit::SubstanceGroup::getCStates;
  return &(self.*getCStates$)();
}

::std::vector<::RDKit::SubstanceGroup::AttachPoint> const *RDKit$cxxbridge1$SubstanceGroup$getAttachPoints(::RDKit::SubstanceGroup const &self) noexcept {
  ::std::vector<::RDKit::SubstanceGroup::AttachPoint> const &(::RDKit::SubstanceGroup::*getAttachPoints$)() const = &::RDKit::SubstanceGroup::getAttachPoints;
  return &(self.*getAttachPoints$)();
}

::std::vector<::RDKit::SubstanceGroup::CState> *RDKit$cxxbridge1$SubstanceGroup$getCStates1(::RDKit::SubstanceGroup &self) noexcept {
  ::std::vector<::RDKit::SubstanceGroup::CState> &(::RDKit::SubstanceGroup::*getCStates1$)() = &::RDKit::SubstanceGroup::getCStates;
  return &(self.*getCStates1$)();
}

::std::vector<::RDKit::SubstanceGroup::AttachPoint> *RDKit$cxxbridge1$SubstanceGroup$getAttachPoints1(::RDKit::SubstanceGroup &self) noexcept {
  ::std::vector<::RDKit::SubstanceGroup::AttachPoint> &(::RDKit::SubstanceGroup::*getAttachPoints1$)() = &::RDKit::SubstanceGroup::getAttachPoints;
  return &(self.*getAttachPoints1$)();
}

void RDKit$cxxbridge1$SubstanceGroup$clearBrackets(::RDKit::SubstanceGroup &self) noexcept {
  void (::RDKit::SubstanceGroup::*clearBrackets$)() = &::RDKit::SubstanceGroup::clearBrackets;
  (self.*clearBrackets$)();
}

void RDKit$cxxbridge1$SubstanceGroup$clearCStates(::RDKit::SubstanceGroup &self) noexcept {
  void (::RDKit::SubstanceGroup::*clearCStates$)() = &::RDKit::SubstanceGroup::clearCStates;
  (self.*clearCStates$)();
}

void RDKit$cxxbridge1$SubstanceGroup$clearAttachPoints(::RDKit::SubstanceGroup &self) noexcept {
  void (::RDKit::SubstanceGroup::*clearAttachPoints$)() = &::RDKit::SubstanceGroup::clearAttachPoints;
  (self.*clearAttachPoints$)();
}

bool RDKit$cxxbridge1$SubstanceGroup$adjustToRemovedAtom(::RDKit::SubstanceGroup &self, ::c_uint *atomIdx) noexcept {
  bool (::RDKit::SubstanceGroup::*adjustToRemovedAtom$)(::c_uint) = &::RDKit::SubstanceGroup::adjustToRemovedAtom;
  return (self.*adjustToRemovedAtom$)(::std::move(*atomIdx));
}

bool RDKit$cxxbridge1$SubstanceGroup$includesAtom(::RDKit::SubstanceGroup const &self, ::c_uint *atomIdx) noexcept {
  bool (::RDKit::SubstanceGroup::*includesAtom$)(::c_uint) const = &::RDKit::SubstanceGroup::includesAtom;
  return (self.*includesAtom$)(::std::move(*atomIdx));
}

bool RDKit$cxxbridge1$SubstanceGroup$adjustToRemovedBond(::RDKit::SubstanceGroup &self, ::c_uint *bondIdx) noexcept {
  bool (::RDKit::SubstanceGroup::*adjustToRemovedBond$)(::c_uint) = &::RDKit::SubstanceGroup::adjustToRemovedBond;
  return (self.*adjustToRemovedBond$)(::std::move(*bondIdx));
}

bool RDKit$cxxbridge1$SubstanceGroup$includesBond(::RDKit::SubstanceGroup const &self, ::c_uint *bondIdx) noexcept {
  bool (::RDKit::SubstanceGroup::*includesBond$)(::c_uint) const = &::RDKit::SubstanceGroup::includesBond;
  return (self.*includesBond$)(::std::move(*bondIdx));
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_SubstanceGroup_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup &autocxx_gen_this, ::RDKit::ROMol *mol) noexcept {
  void (*RDKit_SubstanceGroup_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup &, ::RDKit::ROMol *) = ::RDKit_SubstanceGroup_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroup_setOwningMol_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, mol);
}

void cxxbridge1$RDKit_SubstanceGroup_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup *autocxx_gen_this, ::RDKit::ROMol *owning_mol, ::std::string const &type_) noexcept {
  void (*RDKit_SubstanceGroup_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup *, ::RDKit::ROMol *, ::std::string const &) = ::RDKit_SubstanceGroup_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroup_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, owning_mol, type_);
}

void cxxbridge1$RDKit_SubstanceGroup_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup *autocxx_gen_this, ::RDKit::SubstanceGroup const &other) noexcept {
  void (*RDKit_SubstanceGroup_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup *, ::RDKit::SubstanceGroup const &) = ::RDKit_SubstanceGroup_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroup_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_SubstanceGroup_new3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup *autocxx_gen_this, ::RDKit::SubstanceGroup *other) noexcept {
  void (*RDKit_SubstanceGroup_new3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup *, ::RDKit::SubstanceGroup *) = ::RDKit_SubstanceGroup_new3_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroup_new3_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$SubstanceGroup_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup *autocxx_gen_this) noexcept {
  void (*SubstanceGroup_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup *) = ::SubstanceGroup_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
::std::vector<::RDKit::SubstanceGroup> *RDKit$cxxbridge1$getSubstanceGroups(::RDKit::ROMol &mol) noexcept {
  ::std::vector<::RDKit::SubstanceGroup> &(*getSubstanceGroups$)(::RDKit::ROMol &) = ::RDKit::getSubstanceGroups;
  return &getSubstanceGroups$(mol);
}

::std::vector<::RDKit::SubstanceGroup> const *RDKit$cxxbridge1$getSubstanceGroups1(::RDKit::ROMol const &mol) noexcept {
  ::std::vector<::RDKit::SubstanceGroup> const &(*getSubstanceGroups1$)(::RDKit::ROMol const &) = ::RDKit::getSubstanceGroups;
  return &getSubstanceGroups1$(mol);
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$addSubstanceGroup_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol &mol, ::RDKit::SubstanceGroup *sgroup, ::c_uint *return$) noexcept {
  ::c_uint (*addSubstanceGroup_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol &, ::RDKit::SubstanceGroup *) = ::addSubstanceGroup_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_uint(addSubstanceGroup_autocxx_wrapper_0x7001b89d03cdd863$(mol, sgroup));
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$removeSubstanceGroupsReferencingAtom(::RDKit::RWMol &mol, ::c_uint *idx) noexcept {
  void (*removeSubstanceGroupsReferencingAtom$)(::RDKit::RWMol &, ::c_uint) = ::RDKit::removeSubstanceGroupsReferencingAtom;
  removeSubstanceGroupsReferencingAtom$(mol, ::std::move(*idx));
}

void RDKit$cxxbridge1$removeSubstanceGroupsReferencingBond(::RDKit::RWMol &mol, ::c_uint *idx) noexcept {
  void (*removeSubstanceGroupsReferencingBond$)(::RDKit::RWMol &, ::c_uint) = ::RDKit::removeSubstanceGroupsReferencingBond;
  removeSubstanceGroupsReferencingBond$(mol, ::std::move(*idx));
}

void RDKit$cxxbridge1$StereoGroup$getGroupType(::RDKit::StereoGroup const &self, ::RDKit::StereoGroupType *return$) noexcept {
  ::RDKit::StereoGroupType (::RDKit::StereoGroup::*getGroupType$)() const = &::RDKit::StereoGroup::getGroupType;
  new (return$) ::RDKit::StereoGroupType((self.*getGroupType$)());
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_StereoGroup_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::StereoGroup *autocxx_gen_this) noexcept {
  void (*RDKit_StereoGroup_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::StereoGroup *) = ::RDKit_StereoGroup_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_StereoGroup_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_StereoGroup_new3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::StereoGroup *autocxx_gen_this, ::RDKit::StereoGroup const &other) noexcept {
  void (*RDKit_StereoGroup_new3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::StereoGroup *, ::RDKit::StereoGroup const &) = ::RDKit_StereoGroup_new3_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_StereoGroup_new3_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_StereoGroup_new4_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::StereoGroup *autocxx_gen_this, ::RDKit::StereoGroup *other) noexcept {
  void (*RDKit_StereoGroup_new4_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::StereoGroup *, ::RDKit::StereoGroup *) = ::RDKit_StereoGroup_new4_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_StereoGroup_new4_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$removeGroupsWithAtom(::RDKit::Atom const *atom, ::std::vector<::RDKit::StereoGroup> &groups) noexcept {
  void (*removeGroupsWithAtom$)(::RDKit::Atom const *, ::std::vector<::RDKit::StereoGroup> &) = ::RDKit::removeGroupsWithAtom;
  removeGroupsWithAtom$(atom, groups);
}

bool RDKit$cxxbridge1$RingInfo$isInitialized(::RDKit::RingInfo const &self) noexcept {
  bool (::RDKit::RingInfo::*isInitialized$)() const = &::RDKit::RingInfo::isInitialized;
  return (self.*isInitialized$)();
}

void RDKit$cxxbridge1$RingInfo$initialize(::RDKit::RingInfo &self) noexcept {
  void (::RDKit::RingInfo::*initialize$)() = &::RDKit::RingInfo::initialize;
  (self.*initialize$)();
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_RingInfo_reset_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RingInfo &autocxx_gen_this) noexcept {
  void (*RDKit_RingInfo_reset_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RingInfo &) = ::RDKit_RingInfo_reset_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RingInfo_reset_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
bool RDKit$cxxbridge1$RingInfo$isAtomInRingOfSize(::RDKit::RingInfo const &self, ::c_uint *idx, ::c_uint *size) noexcept {
  bool (::RDKit::RingInfo::*isAtomInRingOfSize$)(::c_uint, ::c_uint) const = &::RDKit::RingInfo::isAtomInRingOfSize;
  return (self.*isAtomInRingOfSize$)(::std::move(*idx), ::std::move(*size));
}

void RDKit$cxxbridge1$RingInfo$numAtomRings(::RDKit::RingInfo const &self, ::c_uint *idx, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::RingInfo::*numAtomRings$)(::c_uint) const = &::RDKit::RingInfo::numAtomRings;
  new (return$) ::c_uint((self.*numAtomRings$)(::std::move(*idx)));
}

void RDKit$cxxbridge1$RingInfo$minAtomRingSize(::RDKit::RingInfo const &self, ::c_uint *idx, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::RingInfo::*minAtomRingSize$)(::c_uint) const = &::RDKit::RingInfo::minAtomRingSize;
  new (return$) ::c_uint((self.*minAtomRingSize$)(::std::move(*idx)));
}

bool RDKit$cxxbridge1$RingInfo$areAtomsInSameRing(::RDKit::RingInfo const &self, ::c_uint *idx1, ::c_uint *idx2) noexcept {
  bool (::RDKit::RingInfo::*areAtomsInSameRing$)(::c_uint, ::c_uint) const = &::RDKit::RingInfo::areAtomsInSameRing;
  return (self.*areAtomsInSameRing$)(::std::move(*idx1), ::std::move(*idx2));
}

bool RDKit$cxxbridge1$RingInfo$areAtomsInSameRingOfSize(::RDKit::RingInfo const &self, ::c_uint *idx1, ::c_uint *idx2, ::c_uint *size) noexcept {
  bool (::RDKit::RingInfo::*areAtomsInSameRingOfSize$)(::c_uint, ::c_uint, ::c_uint) const = &::RDKit::RingInfo::areAtomsInSameRingOfSize;
  return (self.*areAtomsInSameRingOfSize$)(::std::move(*idx1), ::std::move(*idx2), ::std::move(*size));
}

bool RDKit$cxxbridge1$RingInfo$isBondInRingOfSize(::RDKit::RingInfo const &self, ::c_uint *idx, ::c_uint *size) noexcept {
  bool (::RDKit::RingInfo::*isBondInRingOfSize$)(::c_uint, ::c_uint) const = &::RDKit::RingInfo::isBondInRingOfSize;
  return (self.*isBondInRingOfSize$)(::std::move(*idx), ::std::move(*size));
}

void RDKit$cxxbridge1$RingInfo$numBondRings(::RDKit::RingInfo const &self, ::c_uint *idx, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::RingInfo::*numBondRings$)(::c_uint) const = &::RDKit::RingInfo::numBondRings;
  new (return$) ::c_uint((self.*numBondRings$)(::std::move(*idx)));
}

void RDKit$cxxbridge1$RingInfo$minBondRingSize(::RDKit::RingInfo const &self, ::c_uint *idx, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::RingInfo::*minBondRingSize$)(::c_uint) const = &::RDKit::RingInfo::minBondRingSize;
  new (return$) ::c_uint((self.*minBondRingSize$)(::std::move(*idx)));
}

void RDKit$cxxbridge1$RingInfo$numRings(::RDKit::RingInfo const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::RingInfo::*numRings$)() const = &::RDKit::RingInfo::numRings;
  new (return$) ::c_uint((self.*numRings$)());
}

bool RDKit$cxxbridge1$RingInfo$areBondsInSameRing(::RDKit::RingInfo const &self, ::c_uint *idx1, ::c_uint *idx2) noexcept {
  bool (::RDKit::RingInfo::*areBondsInSameRing$)(::c_uint, ::c_uint) const = &::RDKit::RingInfo::areBondsInSameRing;
  return (self.*areBondsInSameRing$)(::std::move(*idx1), ::std::move(*idx2));
}

bool RDKit$cxxbridge1$RingInfo$areBondsInSameRingOfSize(::RDKit::RingInfo const &self, ::c_uint *idx1, ::c_uint *idx2, ::c_uint *size) noexcept {
  bool (::RDKit::RingInfo::*areBondsInSameRingOfSize$)(::c_uint, ::c_uint, ::c_uint) const = &::RDKit::RingInfo::areBondsInSameRingOfSize;
  return (self.*areBondsInSameRingOfSize$)(::std::move(*idx1), ::std::move(*idx2), ::std::move(*size));
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_RingInfo_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RingInfo *autocxx_gen_this) noexcept {
  void (*RDKit_RingInfo_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RingInfo *) = ::RDKit_RingInfo_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RingInfo_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_RingInfo_new1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RingInfo *autocxx_gen_this, ::RDKit::RingInfo const &other) noexcept {
  void (*RDKit_RingInfo_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RingInfo *, ::RDKit::RingInfo const &) = ::RDKit_RingInfo_new1_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RingInfo_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_RingInfo_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RingInfo *autocxx_gen_this, ::RDKit::RingInfo *other) noexcept {
  void (*RDKit_RingInfo_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RingInfo *, ::RDKit::RingInfo *) = ::RDKit_RingInfo_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RingInfo_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_ROMol_getNumAtoms_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol const &autocxx_gen_this, ::c_uint *return$) noexcept {
  ::c_uint (*RDKit_ROMol_getNumAtoms_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol const &) = ::RDKit_ROMol_getNumAtoms_autocxx_wrapper_0x7001b89d03cdd863;
  new (return$) ::c_uint(RDKit_ROMol_getNumAtoms_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this));
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$ROMol$getNumAtoms1(::RDKit::ROMol const &self, bool onlyExplicit, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::ROMol::*getNumAtoms1$)(bool) const = &::RDKit::ROMol::getNumAtoms;
  new (return$) ::c_uint((self.*getNumAtoms1$)(onlyExplicit));
}

void RDKit$cxxbridge1$ROMol$getNumHeavyAtoms(::RDKit::ROMol const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::ROMol::*getNumHeavyAtoms$)() const = &::RDKit::ROMol::getNumHeavyAtoms;
  new (return$) ::c_uint((self.*getNumHeavyAtoms$)());
}

::RDKit::Atom *RDKit$cxxbridge1$ROMol$getAtomWithIdx(::RDKit::ROMol &self, ::c_uint *idx) noexcept {
  ::RDKit::Atom *(::RDKit::ROMol::*getAtomWithIdx$)(::c_uint) = &::RDKit::ROMol::getAtomWithIdx;
  return (self.*getAtomWithIdx$)(::std::move(*idx));
}

::RDKit::Atom const *RDKit$cxxbridge1$ROMol$getAtomWithIdx1(::RDKit::ROMol const &self, ::c_uint *idx) noexcept {
  ::RDKit::Atom const *(::RDKit::ROMol::*getAtomWithIdx1$)(::c_uint) const = &::RDKit::ROMol::getAtomWithIdx;
  return (self.*getAtomWithIdx1$)(::std::move(*idx));
}

void RDKit$cxxbridge1$ROMol$getAtomDegree(::RDKit::ROMol const &self, ::RDKit::Atom const *at, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::ROMol::*getAtomDegree$)(::RDKit::Atom const *) const = &::RDKit::ROMol::getAtomDegree;
  new (return$) ::c_uint((self.*getAtomDegree$)(at));
}

void RDKit$cxxbridge1$ROMol$getNumBonds(::RDKit::ROMol const &self, bool onlyHeavy, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::ROMol::*getNumBonds$)(bool) const = &::RDKit::ROMol::getNumBonds;
  new (return$) ::c_uint((self.*getNumBonds$)(onlyHeavy));
}

::RDKit::Bond *RDKit$cxxbridge1$ROMol$getBondWithIdx(::RDKit::ROMol &self, ::c_uint *idx) noexcept {
  ::RDKit::Bond *(::RDKit::ROMol::*getBondWithIdx$)(::c_uint) = &::RDKit::ROMol::getBondWithIdx;
  return (self.*getBondWithIdx$)(::std::move(*idx));
}

::RDKit::Bond const *RDKit$cxxbridge1$ROMol$getBondWithIdx1(::RDKit::ROMol const &self, ::c_uint *idx) noexcept {
  ::RDKit::Bond const *(::RDKit::ROMol::*getBondWithIdx1$)(::c_uint) const = &::RDKit::ROMol::getBondWithIdx;
  return (self.*getBondWithIdx1$)(::std::move(*idx));
}

::RDKit::Bond *RDKit$cxxbridge1$ROMol$getBondBetweenAtoms(::RDKit::ROMol &self, ::c_uint *idx1, ::c_uint *idx2) noexcept {
  ::RDKit::Bond *(::RDKit::ROMol::*getBondBetweenAtoms$)(::c_uint, ::c_uint) = &::RDKit::ROMol::getBondBetweenAtoms;
  return (self.*getBondBetweenAtoms$)(::std::move(*idx1), ::std::move(*idx2));
}

::RDKit::Bond const *RDKit$cxxbridge1$ROMol$getBondBetweenAtoms1(::RDKit::ROMol const &self, ::c_uint *idx1, ::c_uint *idx2) noexcept {
  ::RDKit::Bond const *(::RDKit::ROMol::*getBondBetweenAtoms1$)(::c_uint, ::c_uint) const = &::RDKit::ROMol::getBondBetweenAtoms;
  return (self.*getBondBetweenAtoms1$)(::std::move(*idx1), ::std::move(*idx2));
}

void RDKit$cxxbridge1$ROMol$setAtomBookmark(::RDKit::ROMol &self, ::RDKit::Atom *at, ::c_int *mark) noexcept {
  void (::RDKit::ROMol::*setAtomBookmark$)(::RDKit::Atom *, ::c_int) = &::RDKit::ROMol::setAtomBookmark;
  (self.*setAtomBookmark$)(at, ::std::move(*mark));
}

void RDKit$cxxbridge1$ROMol$replaceAtomBookmark(::RDKit::ROMol &self, ::RDKit::Atom *at, ::c_int *mark) noexcept {
  void (::RDKit::ROMol::*replaceAtomBookmark$)(::RDKit::Atom *, ::c_int) = &::RDKit::ROMol::replaceAtomBookmark;
  (self.*replaceAtomBookmark$)(at, ::std::move(*mark));
}

::RDKit::Atom *RDKit$cxxbridge1$ROMol$getAtomWithBookmark(::RDKit::ROMol &self, ::c_int *mark) noexcept {
  ::RDKit::Atom *(::RDKit::ROMol::*getAtomWithBookmark$)(::c_int) = &::RDKit::ROMol::getAtomWithBookmark;
  return (self.*getAtomWithBookmark$)(::std::move(*mark));
}

::RDKit::Atom *RDKit$cxxbridge1$ROMol$getUniqueAtomWithBookmark(::RDKit::ROMol &self, ::c_int *mark) noexcept {
  ::RDKit::Atom *(::RDKit::ROMol::*getUniqueAtomWithBookmark$)(::c_int) = &::RDKit::ROMol::getUniqueAtomWithBookmark;
  return (self.*getUniqueAtomWithBookmark$)(::std::move(*mark));
}

void RDKit$cxxbridge1$ROMol$clearAtomBookmark(::RDKit::ROMol &self, ::c_int *mark) noexcept {
  void (::RDKit::ROMol::*clearAtomBookmark$)(::c_int) = &::RDKit::ROMol::clearAtomBookmark;
  (self.*clearAtomBookmark$)(::std::move(*mark));
}

void RDKit$cxxbridge1$ROMol$clearAtomBookmark1(::RDKit::ROMol &self, ::c_int *mark, ::RDKit::Atom const *atom) noexcept {
  void (::RDKit::ROMol::*clearAtomBookmark1$)(::c_int, ::RDKit::Atom const *) = &::RDKit::ROMol::clearAtomBookmark;
  (self.*clearAtomBookmark1$)(::std::move(*mark), atom);
}

void RDKit$cxxbridge1$ROMol$clearAllAtomBookmarks(::RDKit::ROMol &self) noexcept {
  void (::RDKit::ROMol::*clearAllAtomBookmarks$)() = &::RDKit::ROMol::clearAllAtomBookmarks;
  (self.*clearAllAtomBookmarks$)();
}

bool RDKit$cxxbridge1$ROMol$hasAtomBookmark(::RDKit::ROMol const &self, ::c_int *mark) noexcept {
  bool (::RDKit::ROMol::*hasAtomBookmark$)(::c_int) const = &::RDKit::ROMol::hasAtomBookmark;
  return (self.*hasAtomBookmark$)(::std::move(*mark));
}

void RDKit$cxxbridge1$ROMol$setBondBookmark(::RDKit::ROMol &self, ::RDKit::Bond *bond, ::c_int *mark) noexcept {
  void (::RDKit::ROMol::*setBondBookmark$)(::RDKit::Bond *, ::c_int) = &::RDKit::ROMol::setBondBookmark;
  (self.*setBondBookmark$)(bond, ::std::move(*mark));
}

::RDKit::Bond *RDKit$cxxbridge1$ROMol$getBondWithBookmark(::RDKit::ROMol &self, ::c_int *mark) noexcept {
  ::RDKit::Bond *(::RDKit::ROMol::*getBondWithBookmark$)(::c_int) = &::RDKit::ROMol::getBondWithBookmark;
  return (self.*getBondWithBookmark$)(::std::move(*mark));
}

::RDKit::Bond *RDKit$cxxbridge1$ROMol$getUniqueBondWithBookmark(::RDKit::ROMol &self, ::c_int *mark) noexcept {
  ::RDKit::Bond *(::RDKit::ROMol::*getUniqueBondWithBookmark$)(::c_int) = &::RDKit::ROMol::getUniqueBondWithBookmark;
  return (self.*getUniqueBondWithBookmark$)(::std::move(*mark));
}

void RDKit$cxxbridge1$ROMol$clearBondBookmark(::RDKit::ROMol &self, ::c_int *mark) noexcept {
  void (::RDKit::ROMol::*clearBondBookmark$)(::c_int) = &::RDKit::ROMol::clearBondBookmark;
  (self.*clearBondBookmark$)(::std::move(*mark));
}

void RDKit$cxxbridge1$ROMol$clearBondBookmark1(::RDKit::ROMol &self, ::c_int *mark, ::RDKit::Bond const *bond) noexcept {
  void (::RDKit::ROMol::*clearBondBookmark1$)(::c_int, ::RDKit::Bond const *) = &::RDKit::ROMol::clearBondBookmark;
  (self.*clearBondBookmark1$)(::std::move(*mark), bond);
}

void RDKit$cxxbridge1$ROMol$clearAllBondBookmarks(::RDKit::ROMol &self) noexcept {
  void (::RDKit::ROMol::*clearAllBondBookmarks$)() = &::RDKit::ROMol::clearAllBondBookmarks;
  (self.*clearAllBondBookmarks$)();
}

bool RDKit$cxxbridge1$ROMol$hasBondBookmark(::RDKit::ROMol const &self, ::c_int *mark) noexcept {
  bool (::RDKit::ROMol::*hasBondBookmark$)(::c_int) const = &::RDKit::ROMol::hasBondBookmark;
  return (self.*hasBondBookmark$)(::std::move(*mark));
}

::RDKit::Conformer const *RDKit$cxxbridge1$ROMol$getConformer(::RDKit::ROMol const &self, ::c_int *id) noexcept {
  ::RDKit::Conformer const &(::RDKit::ROMol::*getConformer$)(::c_int) const = &::RDKit::ROMol::getConformer;
  return &(self.*getConformer$)(::std::move(*id));
}

::RDKit::Conformer *RDKit$cxxbridge1$ROMol$getConformer1(::RDKit::ROMol &self, ::c_int *id) noexcept {
  ::RDKit::Conformer &(::RDKit::ROMol::*getConformer1$)(::c_int) = &::RDKit::ROMol::getConformer;
  return &(self.*getConformer1$)(::std::move(*id));
}

void RDKit$cxxbridge1$ROMol$removeConformer(::RDKit::ROMol &self, ::c_uint *id) noexcept {
  void (::RDKit::ROMol::*removeConformer$)(::c_uint) = &::RDKit::ROMol::removeConformer;
  (self.*removeConformer$)(::std::move(*id));
}

void RDKit$cxxbridge1$ROMol$clearConformers(::RDKit::ROMol &self) noexcept {
  void (::RDKit::ROMol::*clearConformers$)() = &::RDKit::ROMol::clearConformers;
  (self.*clearConformers$)();
}

void RDKit$cxxbridge1$ROMol$addConformer(::RDKit::ROMol &self, ::RDKit::Conformer *conf, bool assignId, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::ROMol::*addConformer$)(::RDKit::Conformer *, bool) = &::RDKit::ROMol::addConformer;
  new (return$) ::c_uint((self.*addConformer$)(conf, assignId));
}

void RDKit$cxxbridge1$ROMol$getNumConformers(::RDKit::ROMol const &self, ::c_uint *return$) noexcept {
  ::c_uint (::RDKit::ROMol::*getNumConformers$)() const = &::RDKit::ROMol::getNumConformers;
  new (return$) ::c_uint((self.*getNumConformers$)());
}

::RDKit::RingInfo *RDKit$cxxbridge1$ROMol$getRingInfo(::RDKit::ROMol const &self) noexcept {
  ::RDKit::RingInfo *(::RDKit::ROMol::*getRingInfo$)() const = &::RDKit::ROMol::getRingInfo;
  return (self.*getRingInfo$)();
}
} // extern "C"
} // namespace RDKit

extern "C" {
::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete *cxxbridge1$getAtomNeighbors_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol const &autocxx_gen_this, ::RDKit::Atom const *at) noexcept {
  ::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> (*getAtomNeighbors_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol const &, ::RDKit::Atom const *) = ::getAtomNeighbors_autocxx_wrapper_0x7001b89d03cdd863;
  return getAtomNeighbors_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, at).release();
}

::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete *cxxbridge1$getAtomBonds_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol const &autocxx_gen_this, ::RDKit::Atom const *at) noexcept {
  ::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> (*getAtomBonds_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol const &, ::RDKit::Atom const *) = ::getAtomBonds_autocxx_wrapper_0x7001b89d03cdd863;
  return getAtomBonds_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, at).release();
}

::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete *cxxbridge1$getVertices_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol &autocxx_gen_this) noexcept {
  ::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> (*getVertices_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol &) = ::getVertices_autocxx_wrapper_0x7001b89d03cdd863;
  return getVertices_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this).release();
}

::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete *cxxbridge1$getEdges_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol &autocxx_gen_this) noexcept {
  ::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> (*getEdges_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol &) = ::getEdges_autocxx_wrapper_0x7001b89d03cdd863;
  return getEdges_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this).release();
}

::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete *cxxbridge1$getVertices1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol const &autocxx_gen_this) noexcept {
  ::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> (*getVertices1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol const &) = ::getVertices1_autocxx_wrapper_0x7001b89d03cdd863;
  return getVertices1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this).release();
}

::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete *cxxbridge1$getEdges1_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol const &autocxx_gen_this) noexcept {
  ::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> (*getEdges1_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol const &) = ::getEdges1_autocxx_wrapper_0x7001b89d03cdd863;
  return getEdges1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this).release();
}
} // extern "C"

namespace RDKit {
extern "C" {
::boost_adjacency_list_boost_no_property_AutocxxConcrete const *RDKit$cxxbridge1$ROMol$getTopology(::RDKit::ROMol const &self) noexcept {
  ::boost_adjacency_list_boost_no_property_AutocxxConcrete const &(::RDKit::ROMol::*getTopology$)() const = &::RDKit::ROMol::getTopology;
  return &(self.*getTopology$)();
}

::std::uint64_t RDKit$cxxbridge1$ROMol$beginConformers(::RDKit::ROMol &self) noexcept {
  ::std::uint64_t (::RDKit::ROMol::*beginConformers$)() = &::RDKit::ROMol::beginConformers;
  return (self.*beginConformers$)();
}

::std::uint64_t RDKit$cxxbridge1$ROMol$endConformers(::RDKit::ROMol &self) noexcept {
  ::std::uint64_t (::RDKit::ROMol::*endConformers$)() = &::RDKit::ROMol::endConformers;
  return (self.*endConformers$)();
}

::std::uint64_t RDKit$cxxbridge1$ROMol$beginConformers1(::RDKit::ROMol const &self) noexcept {
  ::std::uint64_t (::RDKit::ROMol::*beginConformers1$)() const = &::RDKit::ROMol::beginConformers;
  return (self.*beginConformers1$)();
}

::std::uint64_t RDKit$cxxbridge1$ROMol$endConformers1(::RDKit::ROMol const &self) noexcept {
  ::std::uint64_t (::RDKit::ROMol::*endConformers1$)() const = &::RDKit::ROMol::endConformers;
  return (self.*endConformers1$)();
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$RDKit_ROMol_clearComputedProps_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol const &autocxx_gen_this, bool includeRings) noexcept {
  void (*RDKit_ROMol_clearComputedProps_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol const &, bool) = ::RDKit_ROMol_clearComputedProps_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ROMol_clearComputedProps_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, includeRings);
}

void cxxbridge1$RDKit_ROMol_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol &autocxx_gen_this, bool strict) noexcept {
  void (*RDKit_ROMol_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol &, bool) = ::RDKit_ROMol_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ROMol_updatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, strict);
}

bool cxxbridge1$RDKit_ROMol_needsUpdatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol const &autocxx_gen_this) noexcept {
  bool (*RDKit_ROMol_needsUpdatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol const &) = ::RDKit_ROMol_needsUpdatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863;
  return RDKit_ROMol_needsUpdatePropertyCache_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}
} // extern "C"

namespace RDKit {
extern "C" {
void RDKit$cxxbridge1$ROMol$debugMol(::RDKit::ROMol const &self, ::std::ostream &str_) noexcept {
  void (::RDKit::ROMol::*debugMol$)(::std::ostream &) const = &::RDKit::ROMol::debugMol;
  (self.*debugMol$)(str_);
}

::std::vector<::RDKit::StereoGroup> const *RDKit$cxxbridge1$ROMol$getStereoGroups(::RDKit::ROMol const &self) noexcept {
  ::std::vector<::RDKit::StereoGroup> const &(::RDKit::ROMol::*getStereoGroups$)() const = &::RDKit::ROMol::getStereoGroups;
  return &(self.*getStereoGroups$)();
}
} // extern "C"
} // namespace RDKit

extern "C" {
void cxxbridge1$setStereoGroups_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol &autocxx_gen_this, ::std::vector<::RDKit::StereoGroup> *stereo_groups) noexcept {
  void (*setStereoGroups_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol &, ::std::vector<::RDKit::StereoGroup> *) = ::setStereoGroups_autocxx_wrapper_0x7001b89d03cdd863;
  setStereoGroups_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, stereo_groups);
}

void cxxbridge1$RDKit_ROMol_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol *autocxx_gen_this) noexcept {
  void (*RDKit_ROMol_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol *) = ::RDKit_ROMol_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ROMol_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_ROMol_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol *autocxx_gen_this, ::std::string const &binStr) noexcept {
  void (*RDKit_ROMol_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol *, ::std::string const &) = ::RDKit_ROMol_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ROMol_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, binStr);
}

void cxxbridge1$RDKit_ROMol_new3_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol *autocxx_gen_this, ::std::string const &binStr, ::c_uint *propertyFlags) noexcept {
  void (*RDKit_ROMol_new3_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol *, ::std::string const &, ::c_uint) = ::RDKit_ROMol_new3_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ROMol_new3_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, binStr, ::std::move(*propertyFlags));
}

void cxxbridge1$RDKit_ROMol_new4_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol *autocxx_gen_this, ::RDKit::ROMol *o) noexcept {
  void (*RDKit_ROMol_new4_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol *, ::RDKit::ROMol *) = ::RDKit_ROMol_new4_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ROMol_new4_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, o);
}

void cxxbridge1$ROMol_destructor_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ROMol *autocxx_gen_this) noexcept {
  void (*ROMol_destructor_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ROMol *) = ::ROMol_destructor_autocxx_wrapper_0x7001b89d03cdd863;
  ROMol_destructor_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_Utils_LocaleSwitcher_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Utils::LocaleSwitcher *autocxx_gen_this, ::RDKit::Utils::LocaleSwitcher const &other) noexcept {
  void (*RDKit_Utils_LocaleSwitcher_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Utils::LocaleSwitcher *, ::RDKit::Utils::LocaleSwitcher const &) = ::RDKit_Utils_LocaleSwitcher_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_Utils_LocaleSwitcher_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::RDKit::RDTypeTag::detail::Value *other) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::RDKit::RDTypeTag::detail::Value *) = ::RDKit_RDTypeTag_detail_Value_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_RDTypeTag_detail_Value_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this, ::RDKit::RDTypeTag::detail::Value const &other) noexcept {
  void (*RDKit_RDTypeTag_detail_Value_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *, ::RDKit::RDTypeTag::detail::Value const &) = ::RDKit_RDTypeTag_detail_Value_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDTypeTag_detail_Value_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$Value_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDTypeTag::detail::Value *autocxx_gen_this) noexcept {
  void (*Value_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDTypeTag::detail::Value *) = ::Value_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  Value_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_RDValue_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::RDKit::RDValue *other) noexcept {
  void (*RDKit_RDValue_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::RDKit::RDValue *) = ::RDKit_RDValue_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_RDValue_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this, ::RDKit::RDValue const &other) noexcept {
  void (*RDKit_RDValue_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *, ::RDKit::RDValue const &) = ::RDKit_RDValue_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_RDValue_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDValue_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDValue *autocxx_gen_this) noexcept {
  void (*RDValue_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDValue *) = ::RDValue_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDValue_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$Dict_Pair_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict::Pair *autocxx_gen_this, ::RDKit::Dict::Pair *other) noexcept {
  void (*Dict_Pair_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict::Pair *, ::RDKit::Dict::Pair *) = ::Dict_Pair_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  Dict_Pair_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$Dict_Pair_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict::Pair *autocxx_gen_this, ::RDKit::Dict::Pair const &other) noexcept {
  void (*Dict_Pair_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict::Pair *, ::RDKit::Dict::Pair const &) = ::Dict_Pair_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  Dict_Pair_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$Dict_Pair_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::Dict::Pair *autocxx_gen_this) noexcept {
  void (*Dict_Pair_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::Dict::Pair *) = ::Dict_Pair_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  Dict_Pair_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_ltDouble_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ltDouble *autocxx_gen_this, ::RDKit::ltDouble *other) noexcept {
  void (*RDKit_ltDouble_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ltDouble *, ::RDKit::ltDouble *) = ::RDKit_ltDouble_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ltDouble_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_ltDouble_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ltDouble *autocxx_gen_this, ::RDKit::ltDouble const &other) noexcept {
  void (*RDKit_ltDouble_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ltDouble *, ::RDKit::ltDouble const &) = ::RDKit_ltDouble_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ltDouble_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$ltDouble_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ltDouble *autocxx_gen_this) noexcept {
  void (*ltDouble_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ltDouble *) = ::ltDouble_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  ltDouble_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_charptr_functor_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::charptr_functor *autocxx_gen_this) noexcept {
  void (*RDKit_charptr_functor_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::charptr_functor *) = ::RDKit_charptr_functor_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_charptr_functor_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_charptr_functor_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::charptr_functor *autocxx_gen_this, ::RDKit::charptr_functor *other) noexcept {
  void (*RDKit_charptr_functor_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::charptr_functor *, ::RDKit::charptr_functor *) = ::RDKit_charptr_functor_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_charptr_functor_new_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_charptr_functor_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::charptr_functor *autocxx_gen_this, ::RDKit::charptr_functor const &other) noexcept {
  void (*RDKit_charptr_functor_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::charptr_functor *, ::RDKit::charptr_functor const &) = ::RDKit_charptr_functor_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_charptr_functor_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$charptr_functor_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::charptr_functor *autocxx_gen_this) noexcept {
  void (*charptr_functor_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::charptr_functor *) = ::charptr_functor_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  charptr_functor_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDProps_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RDProps *autocxx_gen_this) noexcept {
  void (*RDProps_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RDProps *) = ::RDProps_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDProps_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_ConformerException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::ConformerException *autocxx_gen_this, ::RDKit::ConformerException const &other) noexcept {
  void (*RDKit_ConformerException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::ConformerException *, ::RDKit::ConformerException const &) = ::RDKit_ConformerException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_ConformerException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$RDKit_SubstanceGroupException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroupException *autocxx_gen_this, ::RDKit::SubstanceGroupException const &other) noexcept {
  void (*RDKit_SubstanceGroupException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroupException *, ::RDKit::SubstanceGroupException const &) = ::RDKit_SubstanceGroupException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroupException_new_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$SubstanceGroupException_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroupException *autocxx_gen_this) noexcept {
  void (*SubstanceGroupException_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroupException *) = ::SubstanceGroupException_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroupException_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_SubstanceGroup_AttachPoint_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::AttachPoint *autocxx_gen_this) noexcept {
  void (*RDKit_SubstanceGroup_AttachPoint_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::AttachPoint *) = ::RDKit_SubstanceGroup_AttachPoint_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroup_AttachPoint_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$SubstanceGroup_AttachPoint_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::AttachPoint *autocxx_gen_this, ::RDKit::SubstanceGroup::AttachPoint *other) noexcept {
  void (*SubstanceGroup_AttachPoint_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::AttachPoint *, ::RDKit::SubstanceGroup::AttachPoint *) = ::SubstanceGroup_AttachPoint_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_AttachPoint_synthetic_move_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$SubstanceGroup_AttachPoint_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::AttachPoint *autocxx_gen_this, ::RDKit::SubstanceGroup::AttachPoint const &other) noexcept {
  void (*SubstanceGroup_AttachPoint_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::AttachPoint *, ::RDKit::SubstanceGroup::AttachPoint const &) = ::SubstanceGroup_AttachPoint_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_AttachPoint_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$SubstanceGroup_AttachPoint_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::AttachPoint *autocxx_gen_this) noexcept {
  void (*SubstanceGroup_AttachPoint_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::AttachPoint *) = ::SubstanceGroup_AttachPoint_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_AttachPoint_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$StereoGroup_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::StereoGroup *autocxx_gen_this) noexcept {
  void (*StereoGroup_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::StereoGroup *) = ::StereoGroup_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  StereoGroup_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RingInfo_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::RingInfo *autocxx_gen_this) noexcept {
  void (*RingInfo_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::RingInfo *) = ::RingInfo_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  RingInfo_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$RDKit_SubstanceGroup_CState_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::CState *autocxx_gen_this) noexcept {
  void (*RDKit_SubstanceGroup_CState_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::CState *) = ::RDKit_SubstanceGroup_CState_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863;
  RDKit_SubstanceGroup_CState_new_autocxx_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

void cxxbridge1$SubstanceGroup_CState_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::CState *autocxx_gen_this, ::RDKit::SubstanceGroup::CState const &other) noexcept {
  void (*SubstanceGroup_CState_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::CState *, ::RDKit::SubstanceGroup::CState const &) = ::SubstanceGroup_CState_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_CState_synthetic_const_copy_ctor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$SubstanceGroup_CState_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863(::RDKit::SubstanceGroup::CState *autocxx_gen_this) noexcept {
  void (*SubstanceGroup_CState_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$)(::RDKit::SubstanceGroup::CState *) = ::SubstanceGroup_CState_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863;
  SubstanceGroup_CState_synthetic_destructor_0x7001b89d03cdd863_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this);
}

::boost::any *cxxbridge1$any_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::boost::any *(*any_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::any_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return any_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$any_free_autocxx_wrapper_0x7001b89d03cdd863(::boost::any *arg0) noexcept {
  void (*any_free_autocxx_wrapper_0x7001b89d03cdd863$)(::boost::any *) = ::any_free_autocxx_wrapper_0x7001b89d03cdd863;
  any_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

void cxxbridge1$boost_any_new1_autocxx_wrapper_0x7001b89d03cdd863(::boost::any *autocxx_gen_this, ::boost::any const &other) noexcept {
  void (*boost_any_new1_autocxx_wrapper_0x7001b89d03cdd863$)(::boost::any *, ::boost::any const &) = ::boost_any_new1_autocxx_wrapper_0x7001b89d03cdd863;
  boost_any_new1_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

void cxxbridge1$boost_any_new2_autocxx_wrapper_0x7001b89d03cdd863(::boost::any *autocxx_gen_this, ::boost::any *other) noexcept {
  void (*boost_any_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::boost::any *, ::boost::any *) = ::boost_any_new2_autocxx_wrapper_0x7001b89d03cdd863;
  boost_any_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

::RDGeom::Point3D *cxxbridge1$Point3D_alloc_autocxx_wrapper_0x7001b89d03cdd863() noexcept {
  ::RDGeom::Point3D *(*Point3D_alloc_autocxx_wrapper_0x7001b89d03cdd863$)() = ::Point3D_alloc_autocxx_wrapper_0x7001b89d03cdd863;
  return Point3D_alloc_autocxx_wrapper_0x7001b89d03cdd863$();
}

void cxxbridge1$Point3D_free_autocxx_wrapper_0x7001b89d03cdd863(::RDGeom::Point3D *arg0) noexcept {
  void (*Point3D_free_autocxx_wrapper_0x7001b89d03cdd863$)(::RDGeom::Point3D *) = ::Point3D_free_autocxx_wrapper_0x7001b89d03cdd863;
  Point3D_free_autocxx_wrapper_0x7001b89d03cdd863$(arg0);
}

void cxxbridge1$RDGeom_Point3D_new2_autocxx_wrapper_0x7001b89d03cdd863(::RDGeom::Point3D *autocxx_gen_this, ::RDGeom::Point3D const &other) noexcept {
  void (*RDGeom_Point3D_new2_autocxx_wrapper_0x7001b89d03cdd863$)(::RDGeom::Point3D *, ::RDGeom::Point3D const &) = ::RDGeom_Point3D_new2_autocxx_wrapper_0x7001b89d03cdd863;
  RDGeom_Point3D_new2_autocxx_wrapper_0x7001b89d03cdd863$(autocxx_gen_this, other);
}

static_assert(::rust::detail::is_complete<::RDKit::Utils::LocaleSwitcher>::value, "definition of LocaleSwitcher is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Utils::LocaleSwitcher>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Utils::LocaleSwitcher>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Utils$LocaleSwitcher$null(::std::unique_ptr<::RDKit::Utils::LocaleSwitcher> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Utils::LocaleSwitcher>();
}
::RDKit::Utils::LocaleSwitcher *cxxbridge1$unique_ptr$RDKit$Utils$LocaleSwitcher$uninit(::std::unique_ptr<::RDKit::Utils::LocaleSwitcher> *ptr) noexcept {
  ::RDKit::Utils::LocaleSwitcher *uninit = reinterpret_cast<::RDKit::Utils::LocaleSwitcher *>(new ::rust::MaybeUninit<::RDKit::Utils::LocaleSwitcher>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Utils::LocaleSwitcher>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Utils$LocaleSwitcher$raw(::std::unique_ptr<::RDKit::Utils::LocaleSwitcher> *ptr, ::RDKit::Utils::LocaleSwitcher *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Utils::LocaleSwitcher>(raw);
}
::RDKit::Utils::LocaleSwitcher const *cxxbridge1$unique_ptr$RDKit$Utils$LocaleSwitcher$get(::std::unique_ptr<::RDKit::Utils::LocaleSwitcher> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Utils::LocaleSwitcher *cxxbridge1$unique_ptr$RDKit$Utils$LocaleSwitcher$release(::std::unique_ptr<::RDKit::Utils::LocaleSwitcher> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Utils$LocaleSwitcher$drop(::std::unique_ptr<::RDKit::Utils::LocaleSwitcher> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Utils::LocaleSwitcher>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Utils::LocaleSwitcher>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Utils::LocaleSwitcher>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Utils$LocaleSwitcher$null(::std::shared_ptr<::RDKit::Utils::LocaleSwitcher> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Utils::LocaleSwitcher>();
}
::RDKit::Utils::LocaleSwitcher *cxxbridge1$shared_ptr$RDKit$Utils$LocaleSwitcher$uninit(::std::shared_ptr<::RDKit::Utils::LocaleSwitcher> *ptr) noexcept {
  ::RDKit::Utils::LocaleSwitcher *uninit = reinterpret_cast<::RDKit::Utils::LocaleSwitcher *>(new ::rust::MaybeUninit<::RDKit::Utils::LocaleSwitcher>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Utils::LocaleSwitcher>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Utils$LocaleSwitcher$clone(::std::shared_ptr<::RDKit::Utils::LocaleSwitcher> const &self, ::std::shared_ptr<::RDKit::Utils::LocaleSwitcher> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Utils::LocaleSwitcher>(self);
}
::RDKit::Utils::LocaleSwitcher const *cxxbridge1$shared_ptr$RDKit$Utils$LocaleSwitcher$get(::std::shared_ptr<::RDKit::Utils::LocaleSwitcher> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Utils$LocaleSwitcher$drop(::std::shared_ptr<::RDKit::Utils::LocaleSwitcher> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Utils::LocaleSwitcher>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Utils::LocaleSwitcher>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Utils$LocaleSwitcher$null(::std::weak_ptr<::RDKit::Utils::LocaleSwitcher> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Utils::LocaleSwitcher>();
}
void cxxbridge1$weak_ptr$RDKit$Utils$LocaleSwitcher$clone(::std::weak_ptr<::RDKit::Utils::LocaleSwitcher> const &self, ::std::weak_ptr<::RDKit::Utils::LocaleSwitcher> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Utils::LocaleSwitcher>(self);
}
void cxxbridge1$weak_ptr$RDKit$Utils$LocaleSwitcher$downgrade(::std::shared_ptr<::RDKit::Utils::LocaleSwitcher> const &shared, ::std::weak_ptr<::RDKit::Utils::LocaleSwitcher> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Utils::LocaleSwitcher>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Utils$LocaleSwitcher$upgrade(::std::weak_ptr<::RDKit::Utils::LocaleSwitcher> const &weak, ::std::shared_ptr<::RDKit::Utils::LocaleSwitcher> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Utils::LocaleSwitcher>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Utils$LocaleSwitcher$drop(::std::weak_ptr<::RDKit::Utils::LocaleSwitcher> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::RDTypeTag::detail::Value>::value, "definition of Value is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::RDTypeTag::detail::Value>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::RDTypeTag::detail::Value>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$RDTypeTag$detail$Value$null(::std::unique_ptr<::RDKit::RDTypeTag::detail::Value> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RDTypeTag::detail::Value>();
}
::RDKit::RDTypeTag::detail::Value *cxxbridge1$unique_ptr$RDKit$RDTypeTag$detail$Value$uninit(::std::unique_ptr<::RDKit::RDTypeTag::detail::Value> *ptr) noexcept {
  ::RDKit::RDTypeTag::detail::Value *uninit = reinterpret_cast<::RDKit::RDTypeTag::detail::Value *>(new ::rust::MaybeUninit<::RDKit::RDTypeTag::detail::Value>);
  ::new (ptr) ::std::unique_ptr<::RDKit::RDTypeTag::detail::Value>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$RDTypeTag$detail$Value$raw(::std::unique_ptr<::RDKit::RDTypeTag::detail::Value> *ptr, ::RDKit::RDTypeTag::detail::Value *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RDTypeTag::detail::Value>(raw);
}
::RDKit::RDTypeTag::detail::Value const *cxxbridge1$unique_ptr$RDKit$RDTypeTag$detail$Value$get(::std::unique_ptr<::RDKit::RDTypeTag::detail::Value> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::RDTypeTag::detail::Value *cxxbridge1$unique_ptr$RDKit$RDTypeTag$detail$Value$release(::std::unique_ptr<::RDKit::RDTypeTag::detail::Value> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$RDTypeTag$detail$Value$drop(::std::unique_ptr<::RDKit::RDTypeTag::detail::Value> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::RDTypeTag::detail::Value>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::RDTypeTag::detail::Value>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::RDTypeTag::detail::Value>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$RDTypeTag$detail$Value$null(::std::shared_ptr<::RDKit::RDTypeTag::detail::Value> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RDTypeTag::detail::Value>();
}
::RDKit::RDTypeTag::detail::Value *cxxbridge1$shared_ptr$RDKit$RDTypeTag$detail$Value$uninit(::std::shared_ptr<::RDKit::RDTypeTag::detail::Value> *ptr) noexcept {
  ::RDKit::RDTypeTag::detail::Value *uninit = reinterpret_cast<::RDKit::RDTypeTag::detail::Value *>(new ::rust::MaybeUninit<::RDKit::RDTypeTag::detail::Value>);
  ::new (ptr) ::std::shared_ptr<::RDKit::RDTypeTag::detail::Value>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$RDTypeTag$detail$Value$clone(::std::shared_ptr<::RDKit::RDTypeTag::detail::Value> const &self, ::std::shared_ptr<::RDKit::RDTypeTag::detail::Value> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RDTypeTag::detail::Value>(self);
}
::RDKit::RDTypeTag::detail::Value const *cxxbridge1$shared_ptr$RDKit$RDTypeTag$detail$Value$get(::std::shared_ptr<::RDKit::RDTypeTag::detail::Value> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$RDTypeTag$detail$Value$drop(::std::shared_ptr<::RDKit::RDTypeTag::detail::Value> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::RDTypeTag::detail::Value>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::RDTypeTag::detail::Value>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$RDTypeTag$detail$Value$null(::std::weak_ptr<::RDKit::RDTypeTag::detail::Value> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RDTypeTag::detail::Value>();
}
void cxxbridge1$weak_ptr$RDKit$RDTypeTag$detail$Value$clone(::std::weak_ptr<::RDKit::RDTypeTag::detail::Value> const &self, ::std::weak_ptr<::RDKit::RDTypeTag::detail::Value> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RDTypeTag::detail::Value>(self);
}
void cxxbridge1$weak_ptr$RDKit$RDTypeTag$detail$Value$downgrade(::std::shared_ptr<::RDKit::RDTypeTag::detail::Value> const &shared, ::std::weak_ptr<::RDKit::RDTypeTag::detail::Value> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::RDTypeTag::detail::Value>(shared);
}
void cxxbridge1$weak_ptr$RDKit$RDTypeTag$detail$Value$upgrade(::std::weak_ptr<::RDKit::RDTypeTag::detail::Value> const &weak, ::std::shared_ptr<::RDKit::RDTypeTag::detail::Value> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::RDTypeTag::detail::Value>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$RDTypeTag$detail$Value$drop(::std::weak_ptr<::RDKit::RDTypeTag::detail::Value> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::RDTypeTag::detail::Value> *cxxbridge1$std$vector$RDKit$RDTypeTag$detail$Value$new() noexcept {
  return new ::std::vector<::RDKit::RDTypeTag::detail::Value>();
}
::std::size_t cxxbridge1$std$vector$RDKit$RDTypeTag$detail$Value$size(::std::vector<::RDKit::RDTypeTag::detail::Value> const &s) noexcept {
  return s.size();
}
::RDKit::RDTypeTag::detail::Value *cxxbridge1$std$vector$RDKit$RDTypeTag$detail$Value$get_unchecked(::std::vector<::RDKit::RDTypeTag::detail::Value> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$RDTypeTag$detail$Value$push_back(::std::vector<::RDKit::RDTypeTag::detail::Value> *v, ::RDKit::RDTypeTag::detail::Value *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$RDTypeTag$detail$Value$pop_back(::std::vector<::RDKit::RDTypeTag::detail::Value> *v, ::RDKit::RDTypeTag::detail::Value *out) noexcept {
  ::new (out) ::RDKit::RDTypeTag::detail::Value(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$RDTypeTag$detail$Value$null(::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$RDTypeTag$detail$Value$raw(::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>> *ptr, ::std::vector<::RDKit::RDTypeTag::detail::Value> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>>(raw);
}
::std::vector<::RDKit::RDTypeTag::detail::Value> const *cxxbridge1$unique_ptr$std$vector$RDKit$RDTypeTag$detail$Value$get(::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::RDTypeTag::detail::Value> *cxxbridge1$unique_ptr$std$vector$RDKit$RDTypeTag$detail$Value$release(::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$RDTypeTag$detail$Value$drop(::std::unique_ptr<::std::vector<::RDKit::RDTypeTag::detail::Value>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::RDValue>::value, "definition of RDValue is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::RDValue>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::RDValue>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$RDValue$null(::std::unique_ptr<::RDKit::RDValue> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RDValue>();
}
::RDKit::RDValue *cxxbridge1$unique_ptr$RDKit$RDValue$uninit(::std::unique_ptr<::RDKit::RDValue> *ptr) noexcept {
  ::RDKit::RDValue *uninit = reinterpret_cast<::RDKit::RDValue *>(new ::rust::MaybeUninit<::RDKit::RDValue>);
  ::new (ptr) ::std::unique_ptr<::RDKit::RDValue>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$RDValue$raw(::std::unique_ptr<::RDKit::RDValue> *ptr, ::RDKit::RDValue *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RDValue>(raw);
}
::RDKit::RDValue const *cxxbridge1$unique_ptr$RDKit$RDValue$get(::std::unique_ptr<::RDKit::RDValue> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::RDValue *cxxbridge1$unique_ptr$RDKit$RDValue$release(::std::unique_ptr<::RDKit::RDValue> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$RDValue$drop(::std::unique_ptr<::RDKit::RDValue> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::RDValue>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::RDValue>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::RDValue>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$RDValue$null(::std::shared_ptr<::RDKit::RDValue> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RDValue>();
}
::RDKit::RDValue *cxxbridge1$shared_ptr$RDKit$RDValue$uninit(::std::shared_ptr<::RDKit::RDValue> *ptr) noexcept {
  ::RDKit::RDValue *uninit = reinterpret_cast<::RDKit::RDValue *>(new ::rust::MaybeUninit<::RDKit::RDValue>);
  ::new (ptr) ::std::shared_ptr<::RDKit::RDValue>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$RDValue$clone(::std::shared_ptr<::RDKit::RDValue> const &self, ::std::shared_ptr<::RDKit::RDValue> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RDValue>(self);
}
::RDKit::RDValue const *cxxbridge1$shared_ptr$RDKit$RDValue$get(::std::shared_ptr<::RDKit::RDValue> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$RDValue$drop(::std::shared_ptr<::RDKit::RDValue> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::RDValue>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::RDValue>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$RDValue$null(::std::weak_ptr<::RDKit::RDValue> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RDValue>();
}
void cxxbridge1$weak_ptr$RDKit$RDValue$clone(::std::weak_ptr<::RDKit::RDValue> const &self, ::std::weak_ptr<::RDKit::RDValue> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RDValue>(self);
}
void cxxbridge1$weak_ptr$RDKit$RDValue$downgrade(::std::shared_ptr<::RDKit::RDValue> const &shared, ::std::weak_ptr<::RDKit::RDValue> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::RDValue>(shared);
}
void cxxbridge1$weak_ptr$RDKit$RDValue$upgrade(::std::weak_ptr<::RDKit::RDValue> const &weak, ::std::shared_ptr<::RDKit::RDValue> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::RDValue>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$RDValue$drop(::std::weak_ptr<::RDKit::RDValue> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::RDValue> *cxxbridge1$std$vector$RDKit$RDValue$new() noexcept {
  return new ::std::vector<::RDKit::RDValue>();
}
::std::size_t cxxbridge1$std$vector$RDKit$RDValue$size(::std::vector<::RDKit::RDValue> const &s) noexcept {
  return s.size();
}
::RDKit::RDValue *cxxbridge1$std$vector$RDKit$RDValue$get_unchecked(::std::vector<::RDKit::RDValue> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$RDValue$push_back(::std::vector<::RDKit::RDValue> *v, ::RDKit::RDValue *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$RDValue$pop_back(::std::vector<::RDKit::RDValue> *v, ::RDKit::RDValue *out) noexcept {
  ::new (out) ::RDKit::RDValue(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::RDValue>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::RDValue>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$RDValue$null(::std::unique_ptr<::std::vector<::RDKit::RDValue>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::RDValue>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$RDValue$raw(::std::unique_ptr<::std::vector<::RDKit::RDValue>> *ptr, ::std::vector<::RDKit::RDValue> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::RDValue>>(raw);
}
::std::vector<::RDKit::RDValue> const *cxxbridge1$unique_ptr$std$vector$RDKit$RDValue$get(::std::unique_ptr<::std::vector<::RDKit::RDValue>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::RDValue> *cxxbridge1$unique_ptr$std$vector$RDKit$RDValue$release(::std::unique_ptr<::std::vector<::RDKit::RDValue>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$RDValue$drop(::std::unique_ptr<::std::vector<::RDKit::RDValue>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::RDAny>::value, "definition of RDAny is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::RDAny>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::RDAny>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$RDAny$null(::std::unique_ptr<::RDKit::RDAny> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RDAny>();
}
::RDKit::RDAny *cxxbridge1$unique_ptr$RDKit$RDAny$uninit(::std::unique_ptr<::RDKit::RDAny> *ptr) noexcept {
  ::RDKit::RDAny *uninit = reinterpret_cast<::RDKit::RDAny *>(new ::rust::MaybeUninit<::RDKit::RDAny>);
  ::new (ptr) ::std::unique_ptr<::RDKit::RDAny>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$RDAny$raw(::std::unique_ptr<::RDKit::RDAny> *ptr, ::RDKit::RDAny *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RDAny>(raw);
}
::RDKit::RDAny const *cxxbridge1$unique_ptr$RDKit$RDAny$get(::std::unique_ptr<::RDKit::RDAny> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::RDAny *cxxbridge1$unique_ptr$RDKit$RDAny$release(::std::unique_ptr<::RDKit::RDAny> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$RDAny$drop(::std::unique_ptr<::RDKit::RDAny> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::RDAny>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::RDAny>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::RDAny>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$RDAny$null(::std::shared_ptr<::RDKit::RDAny> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RDAny>();
}
::RDKit::RDAny *cxxbridge1$shared_ptr$RDKit$RDAny$uninit(::std::shared_ptr<::RDKit::RDAny> *ptr) noexcept {
  ::RDKit::RDAny *uninit = reinterpret_cast<::RDKit::RDAny *>(new ::rust::MaybeUninit<::RDKit::RDAny>);
  ::new (ptr) ::std::shared_ptr<::RDKit::RDAny>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$RDAny$clone(::std::shared_ptr<::RDKit::RDAny> const &self, ::std::shared_ptr<::RDKit::RDAny> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RDAny>(self);
}
::RDKit::RDAny const *cxxbridge1$shared_ptr$RDKit$RDAny$get(::std::shared_ptr<::RDKit::RDAny> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$RDAny$drop(::std::shared_ptr<::RDKit::RDAny> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::RDAny>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::RDAny>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$RDAny$null(::std::weak_ptr<::RDKit::RDAny> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RDAny>();
}
void cxxbridge1$weak_ptr$RDKit$RDAny$clone(::std::weak_ptr<::RDKit::RDAny> const &self, ::std::weak_ptr<::RDKit::RDAny> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RDAny>(self);
}
void cxxbridge1$weak_ptr$RDKit$RDAny$downgrade(::std::shared_ptr<::RDKit::RDAny> const &shared, ::std::weak_ptr<::RDKit::RDAny> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::RDAny>(shared);
}
void cxxbridge1$weak_ptr$RDKit$RDAny$upgrade(::std::weak_ptr<::RDKit::RDAny> const &weak, ::std::shared_ptr<::RDKit::RDAny> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::RDAny>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$RDAny$drop(::std::weak_ptr<::RDKit::RDAny> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Dict>::value, "definition of Dict is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Dict>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Dict>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Dict$null(::std::unique_ptr<::RDKit::Dict> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Dict>();
}
::RDKit::Dict *cxxbridge1$unique_ptr$RDKit$Dict$uninit(::std::unique_ptr<::RDKit::Dict> *ptr) noexcept {
  ::RDKit::Dict *uninit = reinterpret_cast<::RDKit::Dict *>(new ::rust::MaybeUninit<::RDKit::Dict>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Dict>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Dict$raw(::std::unique_ptr<::RDKit::Dict> *ptr, ::RDKit::Dict *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Dict>(raw);
}
::RDKit::Dict const *cxxbridge1$unique_ptr$RDKit$Dict$get(::std::unique_ptr<::RDKit::Dict> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Dict *cxxbridge1$unique_ptr$RDKit$Dict$release(::std::unique_ptr<::RDKit::Dict> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Dict$drop(::std::unique_ptr<::RDKit::Dict> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Dict>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Dict>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Dict>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Dict$null(::std::shared_ptr<::RDKit::Dict> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Dict>();
}
::RDKit::Dict *cxxbridge1$shared_ptr$RDKit$Dict$uninit(::std::shared_ptr<::RDKit::Dict> *ptr) noexcept {
  ::RDKit::Dict *uninit = reinterpret_cast<::RDKit::Dict *>(new ::rust::MaybeUninit<::RDKit::Dict>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Dict>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Dict$clone(::std::shared_ptr<::RDKit::Dict> const &self, ::std::shared_ptr<::RDKit::Dict> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Dict>(self);
}
::RDKit::Dict const *cxxbridge1$shared_ptr$RDKit$Dict$get(::std::shared_ptr<::RDKit::Dict> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Dict$drop(::std::shared_ptr<::RDKit::Dict> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Dict>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Dict>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Dict$null(::std::weak_ptr<::RDKit::Dict> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Dict>();
}
void cxxbridge1$weak_ptr$RDKit$Dict$clone(::std::weak_ptr<::RDKit::Dict> const &self, ::std::weak_ptr<::RDKit::Dict> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Dict>(self);
}
void cxxbridge1$weak_ptr$RDKit$Dict$downgrade(::std::shared_ptr<::RDKit::Dict> const &shared, ::std::weak_ptr<::RDKit::Dict> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Dict>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Dict$upgrade(::std::weak_ptr<::RDKit::Dict> const &weak, ::std::shared_ptr<::RDKit::Dict> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Dict>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Dict$drop(::std::weak_ptr<::RDKit::Dict> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Dict> *cxxbridge1$std$vector$RDKit$Dict$new() noexcept {
  return new ::std::vector<::RDKit::Dict>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Dict$size(::std::vector<::RDKit::Dict> const &s) noexcept {
  return s.size();
}
::RDKit::Dict *cxxbridge1$std$vector$RDKit$Dict$get_unchecked(::std::vector<::RDKit::Dict> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Dict$push_back(::std::vector<::RDKit::Dict> *v, ::RDKit::Dict *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Dict$pop_back(::std::vector<::RDKit::Dict> *v, ::RDKit::Dict *out) noexcept {
  ::new (out) ::RDKit::Dict(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Dict>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Dict>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Dict$null(::std::unique_ptr<::std::vector<::RDKit::Dict>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Dict>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Dict$raw(::std::unique_ptr<::std::vector<::RDKit::Dict>> *ptr, ::std::vector<::RDKit::Dict> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Dict>>(raw);
}
::std::vector<::RDKit::Dict> const *cxxbridge1$unique_ptr$std$vector$RDKit$Dict$get(::std::unique_ptr<::std::vector<::RDKit::Dict>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Dict> *cxxbridge1$unique_ptr$std$vector$RDKit$Dict$release(::std::unique_ptr<::std::vector<::RDKit::Dict>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Dict$drop(::std::unique_ptr<::std::vector<::RDKit::Dict>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Dict::Pair>::value, "definition of Pair is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Dict::Pair>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Dict::Pair>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Dict$Pair$null(::std::unique_ptr<::RDKit::Dict::Pair> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Dict::Pair>();
}
::RDKit::Dict::Pair *cxxbridge1$unique_ptr$RDKit$Dict$Pair$uninit(::std::unique_ptr<::RDKit::Dict::Pair> *ptr) noexcept {
  ::RDKit::Dict::Pair *uninit = reinterpret_cast<::RDKit::Dict::Pair *>(new ::rust::MaybeUninit<::RDKit::Dict::Pair>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Dict::Pair>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Dict$Pair$raw(::std::unique_ptr<::RDKit::Dict::Pair> *ptr, ::RDKit::Dict::Pair *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Dict::Pair>(raw);
}
::RDKit::Dict::Pair const *cxxbridge1$unique_ptr$RDKit$Dict$Pair$get(::std::unique_ptr<::RDKit::Dict::Pair> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Dict::Pair *cxxbridge1$unique_ptr$RDKit$Dict$Pair$release(::std::unique_ptr<::RDKit::Dict::Pair> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Dict$Pair$drop(::std::unique_ptr<::RDKit::Dict::Pair> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Dict::Pair>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Dict::Pair>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Dict::Pair>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Dict$Pair$null(::std::shared_ptr<::RDKit::Dict::Pair> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Dict::Pair>();
}
::RDKit::Dict::Pair *cxxbridge1$shared_ptr$RDKit$Dict$Pair$uninit(::std::shared_ptr<::RDKit::Dict::Pair> *ptr) noexcept {
  ::RDKit::Dict::Pair *uninit = reinterpret_cast<::RDKit::Dict::Pair *>(new ::rust::MaybeUninit<::RDKit::Dict::Pair>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Dict::Pair>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Dict$Pair$clone(::std::shared_ptr<::RDKit::Dict::Pair> const &self, ::std::shared_ptr<::RDKit::Dict::Pair> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Dict::Pair>(self);
}
::RDKit::Dict::Pair const *cxxbridge1$shared_ptr$RDKit$Dict$Pair$get(::std::shared_ptr<::RDKit::Dict::Pair> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Dict$Pair$drop(::std::shared_ptr<::RDKit::Dict::Pair> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Dict::Pair>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Dict::Pair>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Dict$Pair$null(::std::weak_ptr<::RDKit::Dict::Pair> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Dict::Pair>();
}
void cxxbridge1$weak_ptr$RDKit$Dict$Pair$clone(::std::weak_ptr<::RDKit::Dict::Pair> const &self, ::std::weak_ptr<::RDKit::Dict::Pair> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Dict::Pair>(self);
}
void cxxbridge1$weak_ptr$RDKit$Dict$Pair$downgrade(::std::shared_ptr<::RDKit::Dict::Pair> const &shared, ::std::weak_ptr<::RDKit::Dict::Pair> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Dict::Pair>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Dict$Pair$upgrade(::std::weak_ptr<::RDKit::Dict::Pair> const &weak, ::std::shared_ptr<::RDKit::Dict::Pair> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Dict::Pair>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Dict$Pair$drop(::std::weak_ptr<::RDKit::Dict::Pair> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Dict::Pair> *cxxbridge1$std$vector$RDKit$Dict$Pair$new() noexcept {
  return new ::std::vector<::RDKit::Dict::Pair>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Dict$Pair$size(::std::vector<::RDKit::Dict::Pair> const &s) noexcept {
  return s.size();
}
::RDKit::Dict::Pair *cxxbridge1$std$vector$RDKit$Dict$Pair$get_unchecked(::std::vector<::RDKit::Dict::Pair> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Dict$Pair$push_back(::std::vector<::RDKit::Dict::Pair> *v, ::RDKit::Dict::Pair *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Dict$Pair$pop_back(::std::vector<::RDKit::Dict::Pair> *v, ::RDKit::Dict::Pair *out) noexcept {
  ::new (out) ::RDKit::Dict::Pair(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Dict$Pair$null(::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Dict$Pair$raw(::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>> *ptr, ::std::vector<::RDKit::Dict::Pair> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>>(raw);
}
::std::vector<::RDKit::Dict::Pair> const *cxxbridge1$unique_ptr$std$vector$RDKit$Dict$Pair$get(::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Dict::Pair> *cxxbridge1$unique_ptr$std$vector$RDKit$Dict$Pair$release(::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Dict$Pair$drop(::std::unique_ptr<::std::vector<::RDKit::Dict::Pair>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::ltDouble>::value, "definition of ltDouble is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::ltDouble>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::ltDouble>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$ltDouble$null(::std::unique_ptr<::RDKit::ltDouble> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::ltDouble>();
}
::RDKit::ltDouble *cxxbridge1$unique_ptr$RDKit$ltDouble$uninit(::std::unique_ptr<::RDKit::ltDouble> *ptr) noexcept {
  ::RDKit::ltDouble *uninit = reinterpret_cast<::RDKit::ltDouble *>(new ::rust::MaybeUninit<::RDKit::ltDouble>);
  ::new (ptr) ::std::unique_ptr<::RDKit::ltDouble>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$ltDouble$raw(::std::unique_ptr<::RDKit::ltDouble> *ptr, ::RDKit::ltDouble *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::ltDouble>(raw);
}
::RDKit::ltDouble const *cxxbridge1$unique_ptr$RDKit$ltDouble$get(::std::unique_ptr<::RDKit::ltDouble> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::ltDouble *cxxbridge1$unique_ptr$RDKit$ltDouble$release(::std::unique_ptr<::RDKit::ltDouble> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$ltDouble$drop(::std::unique_ptr<::RDKit::ltDouble> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::ltDouble>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::ltDouble>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::ltDouble>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$ltDouble$null(::std::shared_ptr<::RDKit::ltDouble> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::ltDouble>();
}
::RDKit::ltDouble *cxxbridge1$shared_ptr$RDKit$ltDouble$uninit(::std::shared_ptr<::RDKit::ltDouble> *ptr) noexcept {
  ::RDKit::ltDouble *uninit = reinterpret_cast<::RDKit::ltDouble *>(new ::rust::MaybeUninit<::RDKit::ltDouble>);
  ::new (ptr) ::std::shared_ptr<::RDKit::ltDouble>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$ltDouble$clone(::std::shared_ptr<::RDKit::ltDouble> const &self, ::std::shared_ptr<::RDKit::ltDouble> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::ltDouble>(self);
}
::RDKit::ltDouble const *cxxbridge1$shared_ptr$RDKit$ltDouble$get(::std::shared_ptr<::RDKit::ltDouble> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$ltDouble$drop(::std::shared_ptr<::RDKit::ltDouble> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::ltDouble>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::ltDouble>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$ltDouble$null(::std::weak_ptr<::RDKit::ltDouble> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::ltDouble>();
}
void cxxbridge1$weak_ptr$RDKit$ltDouble$clone(::std::weak_ptr<::RDKit::ltDouble> const &self, ::std::weak_ptr<::RDKit::ltDouble> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::ltDouble>(self);
}
void cxxbridge1$weak_ptr$RDKit$ltDouble$downgrade(::std::shared_ptr<::RDKit::ltDouble> const &shared, ::std::weak_ptr<::RDKit::ltDouble> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::ltDouble>(shared);
}
void cxxbridge1$weak_ptr$RDKit$ltDouble$upgrade(::std::weak_ptr<::RDKit::ltDouble> const &weak, ::std::shared_ptr<::RDKit::ltDouble> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::ltDouble>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$ltDouble$drop(::std::weak_ptr<::RDKit::ltDouble> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::ltDouble> *cxxbridge1$std$vector$RDKit$ltDouble$new() noexcept {
  return new ::std::vector<::RDKit::ltDouble>();
}
::std::size_t cxxbridge1$std$vector$RDKit$ltDouble$size(::std::vector<::RDKit::ltDouble> const &s) noexcept {
  return s.size();
}
::RDKit::ltDouble *cxxbridge1$std$vector$RDKit$ltDouble$get_unchecked(::std::vector<::RDKit::ltDouble> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$ltDouble$push_back(::std::vector<::RDKit::ltDouble> *v, ::RDKit::ltDouble *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$ltDouble$pop_back(::std::vector<::RDKit::ltDouble> *v, ::RDKit::ltDouble *out) noexcept {
  ::new (out) ::RDKit::ltDouble(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::ltDouble>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::ltDouble>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$ltDouble$null(::std::unique_ptr<::std::vector<::RDKit::ltDouble>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::ltDouble>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$ltDouble$raw(::std::unique_ptr<::std::vector<::RDKit::ltDouble>> *ptr, ::std::vector<::RDKit::ltDouble> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::ltDouble>>(raw);
}
::std::vector<::RDKit::ltDouble> const *cxxbridge1$unique_ptr$std$vector$RDKit$ltDouble$get(::std::unique_ptr<::std::vector<::RDKit::ltDouble>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::ltDouble> *cxxbridge1$unique_ptr$std$vector$RDKit$ltDouble$release(::std::unique_ptr<::std::vector<::RDKit::ltDouble>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$ltDouble$drop(::std::unique_ptr<::std::vector<::RDKit::ltDouble>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::charptr_functor>::value, "definition of charptr_functor is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::charptr_functor>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::charptr_functor>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$charptr_functor$null(::std::unique_ptr<::RDKit::charptr_functor> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::charptr_functor>();
}
::RDKit::charptr_functor *cxxbridge1$unique_ptr$RDKit$charptr_functor$uninit(::std::unique_ptr<::RDKit::charptr_functor> *ptr) noexcept {
  ::RDKit::charptr_functor *uninit = reinterpret_cast<::RDKit::charptr_functor *>(new ::rust::MaybeUninit<::RDKit::charptr_functor>);
  ::new (ptr) ::std::unique_ptr<::RDKit::charptr_functor>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$charptr_functor$raw(::std::unique_ptr<::RDKit::charptr_functor> *ptr, ::RDKit::charptr_functor *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::charptr_functor>(raw);
}
::RDKit::charptr_functor const *cxxbridge1$unique_ptr$RDKit$charptr_functor$get(::std::unique_ptr<::RDKit::charptr_functor> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::charptr_functor *cxxbridge1$unique_ptr$RDKit$charptr_functor$release(::std::unique_ptr<::RDKit::charptr_functor> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$charptr_functor$drop(::std::unique_ptr<::RDKit::charptr_functor> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::charptr_functor>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::charptr_functor>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::charptr_functor>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$charptr_functor$null(::std::shared_ptr<::RDKit::charptr_functor> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::charptr_functor>();
}
::RDKit::charptr_functor *cxxbridge1$shared_ptr$RDKit$charptr_functor$uninit(::std::shared_ptr<::RDKit::charptr_functor> *ptr) noexcept {
  ::RDKit::charptr_functor *uninit = reinterpret_cast<::RDKit::charptr_functor *>(new ::rust::MaybeUninit<::RDKit::charptr_functor>);
  ::new (ptr) ::std::shared_ptr<::RDKit::charptr_functor>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$charptr_functor$clone(::std::shared_ptr<::RDKit::charptr_functor> const &self, ::std::shared_ptr<::RDKit::charptr_functor> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::charptr_functor>(self);
}
::RDKit::charptr_functor const *cxxbridge1$shared_ptr$RDKit$charptr_functor$get(::std::shared_ptr<::RDKit::charptr_functor> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$charptr_functor$drop(::std::shared_ptr<::RDKit::charptr_functor> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::charptr_functor>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::charptr_functor>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$charptr_functor$null(::std::weak_ptr<::RDKit::charptr_functor> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::charptr_functor>();
}
void cxxbridge1$weak_ptr$RDKit$charptr_functor$clone(::std::weak_ptr<::RDKit::charptr_functor> const &self, ::std::weak_ptr<::RDKit::charptr_functor> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::charptr_functor>(self);
}
void cxxbridge1$weak_ptr$RDKit$charptr_functor$downgrade(::std::shared_ptr<::RDKit::charptr_functor> const &shared, ::std::weak_ptr<::RDKit::charptr_functor> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::charptr_functor>(shared);
}
void cxxbridge1$weak_ptr$RDKit$charptr_functor$upgrade(::std::weak_ptr<::RDKit::charptr_functor> const &weak, ::std::shared_ptr<::RDKit::charptr_functor> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::charptr_functor>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$charptr_functor$drop(::std::weak_ptr<::RDKit::charptr_functor> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::charptr_functor> *cxxbridge1$std$vector$RDKit$charptr_functor$new() noexcept {
  return new ::std::vector<::RDKit::charptr_functor>();
}
::std::size_t cxxbridge1$std$vector$RDKit$charptr_functor$size(::std::vector<::RDKit::charptr_functor> const &s) noexcept {
  return s.size();
}
::RDKit::charptr_functor *cxxbridge1$std$vector$RDKit$charptr_functor$get_unchecked(::std::vector<::RDKit::charptr_functor> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$charptr_functor$push_back(::std::vector<::RDKit::charptr_functor> *v, ::RDKit::charptr_functor *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$charptr_functor$pop_back(::std::vector<::RDKit::charptr_functor> *v, ::RDKit::charptr_functor *out) noexcept {
  ::new (out) ::RDKit::charptr_functor(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::charptr_functor>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::charptr_functor>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$charptr_functor$null(::std::unique_ptr<::std::vector<::RDKit::charptr_functor>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::charptr_functor>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$charptr_functor$raw(::std::unique_ptr<::std::vector<::RDKit::charptr_functor>> *ptr, ::std::vector<::RDKit::charptr_functor> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::charptr_functor>>(raw);
}
::std::vector<::RDKit::charptr_functor> const *cxxbridge1$unique_ptr$std$vector$RDKit$charptr_functor$get(::std::unique_ptr<::std::vector<::RDKit::charptr_functor>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::charptr_functor> *cxxbridge1$unique_ptr$std$vector$RDKit$charptr_functor$release(::std::unique_ptr<::std::vector<::RDKit::charptr_functor>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$charptr_functor$drop(::std::unique_ptr<::std::vector<::RDKit::charptr_functor>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::RDProps>::value, "definition of RDProps is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::RDProps>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::RDProps>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$RDProps$null(::std::unique_ptr<::RDKit::RDProps> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RDProps>();
}
::RDKit::RDProps *cxxbridge1$unique_ptr$RDKit$RDProps$uninit(::std::unique_ptr<::RDKit::RDProps> *ptr) noexcept {
  ::RDKit::RDProps *uninit = reinterpret_cast<::RDKit::RDProps *>(new ::rust::MaybeUninit<::RDKit::RDProps>);
  ::new (ptr) ::std::unique_ptr<::RDKit::RDProps>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$RDProps$raw(::std::unique_ptr<::RDKit::RDProps> *ptr, ::RDKit::RDProps *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RDProps>(raw);
}
::RDKit::RDProps const *cxxbridge1$unique_ptr$RDKit$RDProps$get(::std::unique_ptr<::RDKit::RDProps> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::RDProps *cxxbridge1$unique_ptr$RDKit$RDProps$release(::std::unique_ptr<::RDKit::RDProps> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$RDProps$drop(::std::unique_ptr<::RDKit::RDProps> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::RDProps>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::RDProps>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::RDProps>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$RDProps$null(::std::shared_ptr<::RDKit::RDProps> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RDProps>();
}
::RDKit::RDProps *cxxbridge1$shared_ptr$RDKit$RDProps$uninit(::std::shared_ptr<::RDKit::RDProps> *ptr) noexcept {
  ::RDKit::RDProps *uninit = reinterpret_cast<::RDKit::RDProps *>(new ::rust::MaybeUninit<::RDKit::RDProps>);
  ::new (ptr) ::std::shared_ptr<::RDKit::RDProps>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$RDProps$clone(::std::shared_ptr<::RDKit::RDProps> const &self, ::std::shared_ptr<::RDKit::RDProps> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RDProps>(self);
}
::RDKit::RDProps const *cxxbridge1$shared_ptr$RDKit$RDProps$get(::std::shared_ptr<::RDKit::RDProps> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$RDProps$drop(::std::shared_ptr<::RDKit::RDProps> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::RDProps>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::RDProps>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$RDProps$null(::std::weak_ptr<::RDKit::RDProps> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RDProps>();
}
void cxxbridge1$weak_ptr$RDKit$RDProps$clone(::std::weak_ptr<::RDKit::RDProps> const &self, ::std::weak_ptr<::RDKit::RDProps> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RDProps>(self);
}
void cxxbridge1$weak_ptr$RDKit$RDProps$downgrade(::std::shared_ptr<::RDKit::RDProps> const &shared, ::std::weak_ptr<::RDKit::RDProps> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::RDProps>(shared);
}
void cxxbridge1$weak_ptr$RDKit$RDProps$upgrade(::std::weak_ptr<::RDKit::RDProps> const &weak, ::std::shared_ptr<::RDKit::RDProps> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::RDProps>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$RDProps$drop(::std::weak_ptr<::RDKit::RDProps> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::RDProps> *cxxbridge1$std$vector$RDKit$RDProps$new() noexcept {
  return new ::std::vector<::RDKit::RDProps>();
}
::std::size_t cxxbridge1$std$vector$RDKit$RDProps$size(::std::vector<::RDKit::RDProps> const &s) noexcept {
  return s.size();
}
::RDKit::RDProps *cxxbridge1$std$vector$RDKit$RDProps$get_unchecked(::std::vector<::RDKit::RDProps> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$RDProps$push_back(::std::vector<::RDKit::RDProps> *v, ::RDKit::RDProps *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$RDProps$pop_back(::std::vector<::RDKit::RDProps> *v, ::RDKit::RDProps *out) noexcept {
  ::new (out) ::RDKit::RDProps(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::RDProps>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::RDProps>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$RDProps$null(::std::unique_ptr<::std::vector<::RDKit::RDProps>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::RDProps>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$RDProps$raw(::std::unique_ptr<::std::vector<::RDKit::RDProps>> *ptr, ::std::vector<::RDKit::RDProps> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::RDProps>>(raw);
}
::std::vector<::RDKit::RDProps> const *cxxbridge1$unique_ptr$std$vector$RDKit$RDProps$get(::std::unique_ptr<::std::vector<::RDKit::RDProps>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::RDProps> *cxxbridge1$unique_ptr$std$vector$RDKit$RDProps$release(::std::unique_ptr<::std::vector<::RDKit::RDProps>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$RDProps$drop(::std::unique_ptr<::std::vector<::RDKit::RDProps>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Atom>::value, "definition of Atom is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Atom>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Atom>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Atom$null(::std::unique_ptr<::RDKit::Atom> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom>();
}
::RDKit::Atom *cxxbridge1$unique_ptr$RDKit$Atom$uninit(::std::unique_ptr<::RDKit::Atom> *ptr) noexcept {
  ::RDKit::Atom *uninit = reinterpret_cast<::RDKit::Atom *>(new ::rust::MaybeUninit<::RDKit::Atom>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Atom$raw(::std::unique_ptr<::RDKit::Atom> *ptr, ::RDKit::Atom *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom>(raw);
}
::RDKit::Atom const *cxxbridge1$unique_ptr$RDKit$Atom$get(::std::unique_ptr<::RDKit::Atom> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Atom *cxxbridge1$unique_ptr$RDKit$Atom$release(::std::unique_ptr<::RDKit::Atom> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Atom$drop(::std::unique_ptr<::RDKit::Atom> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Atom>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Atom>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Atom>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Atom$null(::std::shared_ptr<::RDKit::Atom> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom>();
}
::RDKit::Atom *cxxbridge1$shared_ptr$RDKit$Atom$uninit(::std::shared_ptr<::RDKit::Atom> *ptr) noexcept {
  ::RDKit::Atom *uninit = reinterpret_cast<::RDKit::Atom *>(new ::rust::MaybeUninit<::RDKit::Atom>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Atom$clone(::std::shared_ptr<::RDKit::Atom> const &self, ::std::shared_ptr<::RDKit::Atom> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom>(self);
}
::RDKit::Atom const *cxxbridge1$shared_ptr$RDKit$Atom$get(::std::shared_ptr<::RDKit::Atom> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Atom$drop(::std::shared_ptr<::RDKit::Atom> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Atom>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Atom>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Atom$null(::std::weak_ptr<::RDKit::Atom> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Atom>();
}
void cxxbridge1$weak_ptr$RDKit$Atom$clone(::std::weak_ptr<::RDKit::Atom> const &self, ::std::weak_ptr<::RDKit::Atom> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Atom>(self);
}
void cxxbridge1$weak_ptr$RDKit$Atom$downgrade(::std::shared_ptr<::RDKit::Atom> const &shared, ::std::weak_ptr<::RDKit::Atom> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Atom>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Atom$upgrade(::std::weak_ptr<::RDKit::Atom> const &weak, ::std::shared_ptr<::RDKit::Atom> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Atom>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Atom$drop(::std::weak_ptr<::RDKit::Atom> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Atom> *cxxbridge1$std$vector$RDKit$Atom$new() noexcept {
  return new ::std::vector<::RDKit::Atom>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Atom$size(::std::vector<::RDKit::Atom> const &s) noexcept {
  return s.size();
}
::RDKit::Atom *cxxbridge1$std$vector$RDKit$Atom$get_unchecked(::std::vector<::RDKit::Atom> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Atom$push_back(::std::vector<::RDKit::Atom> *v, ::RDKit::Atom *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Atom$pop_back(::std::vector<::RDKit::Atom> *v, ::RDKit::Atom *out) noexcept {
  ::new (out) ::RDKit::Atom(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Atom>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Atom>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$null(::std::unique_ptr<::std::vector<::RDKit::Atom>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Atom>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$raw(::std::unique_ptr<::std::vector<::RDKit::Atom>> *ptr, ::std::vector<::RDKit::Atom> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Atom>>(raw);
}
::std::vector<::RDKit::Atom> const *cxxbridge1$unique_ptr$std$vector$RDKit$Atom$get(::std::unique_ptr<::std::vector<::RDKit::Atom>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Atom> *cxxbridge1$unique_ptr$std$vector$RDKit$Atom$release(::std::unique_ptr<::std::vector<::RDKit::Atom>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$drop(::std::unique_ptr<::std::vector<::RDKit::Atom>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Atom::HybridizationType>::value, "definition of HybridizationType is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Atom::HybridizationType>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Atom::HybridizationType>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Atom$HybridizationType$null(::std::unique_ptr<::RDKit::Atom::HybridizationType> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom::HybridizationType>();
}
::RDKit::Atom::HybridizationType *cxxbridge1$unique_ptr$RDKit$Atom$HybridizationType$uninit(::std::unique_ptr<::RDKit::Atom::HybridizationType> *ptr) noexcept {
  ::RDKit::Atom::HybridizationType *uninit = reinterpret_cast<::RDKit::Atom::HybridizationType *>(new ::rust::MaybeUninit<::RDKit::Atom::HybridizationType>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom::HybridizationType>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Atom$HybridizationType$raw(::std::unique_ptr<::RDKit::Atom::HybridizationType> *ptr, ::RDKit::Atom::HybridizationType *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom::HybridizationType>(raw);
}
::RDKit::Atom::HybridizationType const *cxxbridge1$unique_ptr$RDKit$Atom$HybridizationType$get(::std::unique_ptr<::RDKit::Atom::HybridizationType> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Atom::HybridizationType *cxxbridge1$unique_ptr$RDKit$Atom$HybridizationType$release(::std::unique_ptr<::RDKit::Atom::HybridizationType> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Atom$HybridizationType$drop(::std::unique_ptr<::RDKit::Atom::HybridizationType> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Atom::HybridizationType>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Atom::HybridizationType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Atom::HybridizationType>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Atom$HybridizationType$null(::std::shared_ptr<::RDKit::Atom::HybridizationType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom::HybridizationType>();
}
::RDKit::Atom::HybridizationType *cxxbridge1$shared_ptr$RDKit$Atom$HybridizationType$uninit(::std::shared_ptr<::RDKit::Atom::HybridizationType> *ptr) noexcept {
  ::RDKit::Atom::HybridizationType *uninit = reinterpret_cast<::RDKit::Atom::HybridizationType *>(new ::rust::MaybeUninit<::RDKit::Atom::HybridizationType>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom::HybridizationType>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Atom$HybridizationType$clone(::std::shared_ptr<::RDKit::Atom::HybridizationType> const &self, ::std::shared_ptr<::RDKit::Atom::HybridizationType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom::HybridizationType>(self);
}
::RDKit::Atom::HybridizationType const *cxxbridge1$shared_ptr$RDKit$Atom$HybridizationType$get(::std::shared_ptr<::RDKit::Atom::HybridizationType> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Atom$HybridizationType$drop(::std::shared_ptr<::RDKit::Atom::HybridizationType> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Atom::HybridizationType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Atom::HybridizationType>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Atom$HybridizationType$null(::std::weak_ptr<::RDKit::Atom::HybridizationType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Atom::HybridizationType>();
}
void cxxbridge1$weak_ptr$RDKit$Atom$HybridizationType$clone(::std::weak_ptr<::RDKit::Atom::HybridizationType> const &self, ::std::weak_ptr<::RDKit::Atom::HybridizationType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Atom::HybridizationType>(self);
}
void cxxbridge1$weak_ptr$RDKit$Atom$HybridizationType$downgrade(::std::shared_ptr<::RDKit::Atom::HybridizationType> const &shared, ::std::weak_ptr<::RDKit::Atom::HybridizationType> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Atom::HybridizationType>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Atom$HybridizationType$upgrade(::std::weak_ptr<::RDKit::Atom::HybridizationType> const &weak, ::std::shared_ptr<::RDKit::Atom::HybridizationType> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Atom::HybridizationType>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Atom$HybridizationType$drop(::std::weak_ptr<::RDKit::Atom::HybridizationType> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Atom::HybridizationType> *cxxbridge1$std$vector$RDKit$Atom$HybridizationType$new() noexcept {
  return new ::std::vector<::RDKit::Atom::HybridizationType>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Atom$HybridizationType$size(::std::vector<::RDKit::Atom::HybridizationType> const &s) noexcept {
  return s.size();
}
::RDKit::Atom::HybridizationType *cxxbridge1$std$vector$RDKit$Atom$HybridizationType$get_unchecked(::std::vector<::RDKit::Atom::HybridizationType> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Atom$HybridizationType$push_back(::std::vector<::RDKit::Atom::HybridizationType> *v, ::RDKit::Atom::HybridizationType *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Atom$HybridizationType$pop_back(::std::vector<::RDKit::Atom::HybridizationType> *v, ::RDKit::Atom::HybridizationType *out) noexcept {
  ::new (out) ::RDKit::Atom::HybridizationType(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$HybridizationType$null(::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$HybridizationType$raw(::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>> *ptr, ::std::vector<::RDKit::Atom::HybridizationType> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>>(raw);
}
::std::vector<::RDKit::Atom::HybridizationType> const *cxxbridge1$unique_ptr$std$vector$RDKit$Atom$HybridizationType$get(::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Atom::HybridizationType> *cxxbridge1$unique_ptr$std$vector$RDKit$Atom$HybridizationType$release(::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$HybridizationType$drop(::std::unique_ptr<::std::vector<::RDKit::Atom::HybridizationType>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Atom::ChiralType>::value, "definition of ChiralType is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Atom::ChiralType>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Atom::ChiralType>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Atom$ChiralType$null(::std::unique_ptr<::RDKit::Atom::ChiralType> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom::ChiralType>();
}
::RDKit::Atom::ChiralType *cxxbridge1$unique_ptr$RDKit$Atom$ChiralType$uninit(::std::unique_ptr<::RDKit::Atom::ChiralType> *ptr) noexcept {
  ::RDKit::Atom::ChiralType *uninit = reinterpret_cast<::RDKit::Atom::ChiralType *>(new ::rust::MaybeUninit<::RDKit::Atom::ChiralType>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom::ChiralType>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Atom$ChiralType$raw(::std::unique_ptr<::RDKit::Atom::ChiralType> *ptr, ::RDKit::Atom::ChiralType *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Atom::ChiralType>(raw);
}
::RDKit::Atom::ChiralType const *cxxbridge1$unique_ptr$RDKit$Atom$ChiralType$get(::std::unique_ptr<::RDKit::Atom::ChiralType> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Atom::ChiralType *cxxbridge1$unique_ptr$RDKit$Atom$ChiralType$release(::std::unique_ptr<::RDKit::Atom::ChiralType> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Atom$ChiralType$drop(::std::unique_ptr<::RDKit::Atom::ChiralType> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Atom::ChiralType>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Atom::ChiralType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Atom::ChiralType>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Atom$ChiralType$null(::std::shared_ptr<::RDKit::Atom::ChiralType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom::ChiralType>();
}
::RDKit::Atom::ChiralType *cxxbridge1$shared_ptr$RDKit$Atom$ChiralType$uninit(::std::shared_ptr<::RDKit::Atom::ChiralType> *ptr) noexcept {
  ::RDKit::Atom::ChiralType *uninit = reinterpret_cast<::RDKit::Atom::ChiralType *>(new ::rust::MaybeUninit<::RDKit::Atom::ChiralType>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom::ChiralType>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Atom$ChiralType$clone(::std::shared_ptr<::RDKit::Atom::ChiralType> const &self, ::std::shared_ptr<::RDKit::Atom::ChiralType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Atom::ChiralType>(self);
}
::RDKit::Atom::ChiralType const *cxxbridge1$shared_ptr$RDKit$Atom$ChiralType$get(::std::shared_ptr<::RDKit::Atom::ChiralType> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Atom$ChiralType$drop(::std::shared_ptr<::RDKit::Atom::ChiralType> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Atom::ChiralType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Atom::ChiralType>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Atom$ChiralType$null(::std::weak_ptr<::RDKit::Atom::ChiralType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Atom::ChiralType>();
}
void cxxbridge1$weak_ptr$RDKit$Atom$ChiralType$clone(::std::weak_ptr<::RDKit::Atom::ChiralType> const &self, ::std::weak_ptr<::RDKit::Atom::ChiralType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Atom::ChiralType>(self);
}
void cxxbridge1$weak_ptr$RDKit$Atom$ChiralType$downgrade(::std::shared_ptr<::RDKit::Atom::ChiralType> const &shared, ::std::weak_ptr<::RDKit::Atom::ChiralType> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Atom::ChiralType>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Atom$ChiralType$upgrade(::std::weak_ptr<::RDKit::Atom::ChiralType> const &weak, ::std::shared_ptr<::RDKit::Atom::ChiralType> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Atom::ChiralType>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Atom$ChiralType$drop(::std::weak_ptr<::RDKit::Atom::ChiralType> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Atom::ChiralType> *cxxbridge1$std$vector$RDKit$Atom$ChiralType$new() noexcept {
  return new ::std::vector<::RDKit::Atom::ChiralType>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Atom$ChiralType$size(::std::vector<::RDKit::Atom::ChiralType> const &s) noexcept {
  return s.size();
}
::RDKit::Atom::ChiralType *cxxbridge1$std$vector$RDKit$Atom$ChiralType$get_unchecked(::std::vector<::RDKit::Atom::ChiralType> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Atom$ChiralType$push_back(::std::vector<::RDKit::Atom::ChiralType> *v, ::RDKit::Atom::ChiralType *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Atom$ChiralType$pop_back(::std::vector<::RDKit::Atom::ChiralType> *v, ::RDKit::Atom::ChiralType *out) noexcept {
  ::new (out) ::RDKit::Atom::ChiralType(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$ChiralType$null(::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$ChiralType$raw(::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>> *ptr, ::std::vector<::RDKit::Atom::ChiralType> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>>(raw);
}
::std::vector<::RDKit::Atom::ChiralType> const *cxxbridge1$unique_ptr$std$vector$RDKit$Atom$ChiralType$get(::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Atom::ChiralType> *cxxbridge1$unique_ptr$std$vector$RDKit$Atom$ChiralType$release(::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Atom$ChiralType$drop(::std::unique_ptr<::std::vector<::RDKit::Atom::ChiralType>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Bond>::value, "definition of Bond is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Bond>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Bond>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Bond$null(::std::unique_ptr<::RDKit::Bond> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond>();
}
::RDKit::Bond *cxxbridge1$unique_ptr$RDKit$Bond$uninit(::std::unique_ptr<::RDKit::Bond> *ptr) noexcept {
  ::RDKit::Bond *uninit = reinterpret_cast<::RDKit::Bond *>(new ::rust::MaybeUninit<::RDKit::Bond>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Bond$raw(::std::unique_ptr<::RDKit::Bond> *ptr, ::RDKit::Bond *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond>(raw);
}
::RDKit::Bond const *cxxbridge1$unique_ptr$RDKit$Bond$get(::std::unique_ptr<::RDKit::Bond> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Bond *cxxbridge1$unique_ptr$RDKit$Bond$release(::std::unique_ptr<::RDKit::Bond> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Bond$drop(::std::unique_ptr<::RDKit::Bond> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Bond>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Bond>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Bond>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Bond$null(::std::shared_ptr<::RDKit::Bond> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond>();
}
::RDKit::Bond *cxxbridge1$shared_ptr$RDKit$Bond$uninit(::std::shared_ptr<::RDKit::Bond> *ptr) noexcept {
  ::RDKit::Bond *uninit = reinterpret_cast<::RDKit::Bond *>(new ::rust::MaybeUninit<::RDKit::Bond>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Bond$clone(::std::shared_ptr<::RDKit::Bond> const &self, ::std::shared_ptr<::RDKit::Bond> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond>(self);
}
::RDKit::Bond const *cxxbridge1$shared_ptr$RDKit$Bond$get(::std::shared_ptr<::RDKit::Bond> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Bond$drop(::std::shared_ptr<::RDKit::Bond> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Bond>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Bond>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Bond$null(::std::weak_ptr<::RDKit::Bond> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Bond>();
}
void cxxbridge1$weak_ptr$RDKit$Bond$clone(::std::weak_ptr<::RDKit::Bond> const &self, ::std::weak_ptr<::RDKit::Bond> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Bond>(self);
}
void cxxbridge1$weak_ptr$RDKit$Bond$downgrade(::std::shared_ptr<::RDKit::Bond> const &shared, ::std::weak_ptr<::RDKit::Bond> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Bond>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Bond$upgrade(::std::weak_ptr<::RDKit::Bond> const &weak, ::std::shared_ptr<::RDKit::Bond> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Bond>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Bond$drop(::std::weak_ptr<::RDKit::Bond> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Bond> *cxxbridge1$std$vector$RDKit$Bond$new() noexcept {
  return new ::std::vector<::RDKit::Bond>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Bond$size(::std::vector<::RDKit::Bond> const &s) noexcept {
  return s.size();
}
::RDKit::Bond *cxxbridge1$std$vector$RDKit$Bond$get_unchecked(::std::vector<::RDKit::Bond> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Bond$push_back(::std::vector<::RDKit::Bond> *v, ::RDKit::Bond *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Bond$pop_back(::std::vector<::RDKit::Bond> *v, ::RDKit::Bond *out) noexcept {
  ::new (out) ::RDKit::Bond(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Bond>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Bond>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$null(::std::unique_ptr<::std::vector<::RDKit::Bond>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Bond>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$raw(::std::unique_ptr<::std::vector<::RDKit::Bond>> *ptr, ::std::vector<::RDKit::Bond> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Bond>>(raw);
}
::std::vector<::RDKit::Bond> const *cxxbridge1$unique_ptr$std$vector$RDKit$Bond$get(::std::unique_ptr<::std::vector<::RDKit::Bond>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Bond> *cxxbridge1$unique_ptr$std$vector$RDKit$Bond$release(::std::unique_ptr<::std::vector<::RDKit::Bond>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$drop(::std::unique_ptr<::std::vector<::RDKit::Bond>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Bond::BondType>::value, "definition of BondType is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Bond::BondType>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Bond::BondType>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Bond$BondType$null(::std::unique_ptr<::RDKit::Bond::BondType> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondType>();
}
::RDKit::Bond::BondType *cxxbridge1$unique_ptr$RDKit$Bond$BondType$uninit(::std::unique_ptr<::RDKit::Bond::BondType> *ptr) noexcept {
  ::RDKit::Bond::BondType *uninit = reinterpret_cast<::RDKit::Bond::BondType *>(new ::rust::MaybeUninit<::RDKit::Bond::BondType>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondType>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Bond$BondType$raw(::std::unique_ptr<::RDKit::Bond::BondType> *ptr, ::RDKit::Bond::BondType *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondType>(raw);
}
::RDKit::Bond::BondType const *cxxbridge1$unique_ptr$RDKit$Bond$BondType$get(::std::unique_ptr<::RDKit::Bond::BondType> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Bond::BondType *cxxbridge1$unique_ptr$RDKit$Bond$BondType$release(::std::unique_ptr<::RDKit::Bond::BondType> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Bond$BondType$drop(::std::unique_ptr<::RDKit::Bond::BondType> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Bond::BondType>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Bond::BondType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Bond::BondType>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Bond$BondType$null(::std::shared_ptr<::RDKit::Bond::BondType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondType>();
}
::RDKit::Bond::BondType *cxxbridge1$shared_ptr$RDKit$Bond$BondType$uninit(::std::shared_ptr<::RDKit::Bond::BondType> *ptr) noexcept {
  ::RDKit::Bond::BondType *uninit = reinterpret_cast<::RDKit::Bond::BondType *>(new ::rust::MaybeUninit<::RDKit::Bond::BondType>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondType>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Bond$BondType$clone(::std::shared_ptr<::RDKit::Bond::BondType> const &self, ::std::shared_ptr<::RDKit::Bond::BondType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondType>(self);
}
::RDKit::Bond::BondType const *cxxbridge1$shared_ptr$RDKit$Bond$BondType$get(::std::shared_ptr<::RDKit::Bond::BondType> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Bond$BondType$drop(::std::shared_ptr<::RDKit::Bond::BondType> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Bond::BondType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Bond::BondType>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Bond$BondType$null(::std::weak_ptr<::RDKit::Bond::BondType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Bond::BondType>();
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondType$clone(::std::weak_ptr<::RDKit::Bond::BondType> const &self, ::std::weak_ptr<::RDKit::Bond::BondType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Bond::BondType>(self);
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondType$downgrade(::std::shared_ptr<::RDKit::Bond::BondType> const &shared, ::std::weak_ptr<::RDKit::Bond::BondType> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Bond::BondType>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondType$upgrade(::std::weak_ptr<::RDKit::Bond::BondType> const &weak, ::std::shared_ptr<::RDKit::Bond::BondType> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Bond::BondType>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondType$drop(::std::weak_ptr<::RDKit::Bond::BondType> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Bond::BondType> *cxxbridge1$std$vector$RDKit$Bond$BondType$new() noexcept {
  return new ::std::vector<::RDKit::Bond::BondType>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Bond$BondType$size(::std::vector<::RDKit::Bond::BondType> const &s) noexcept {
  return s.size();
}
::RDKit::Bond::BondType *cxxbridge1$std$vector$RDKit$Bond$BondType$get_unchecked(::std::vector<::RDKit::Bond::BondType> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Bond$BondType$push_back(::std::vector<::RDKit::Bond::BondType> *v, ::RDKit::Bond::BondType *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Bond$BondType$pop_back(::std::vector<::RDKit::Bond::BondType> *v, ::RDKit::Bond::BondType *out) noexcept {
  ::new (out) ::RDKit::Bond::BondType(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondType$null(::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondType$raw(::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>> *ptr, ::std::vector<::RDKit::Bond::BondType> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>>(raw);
}
::std::vector<::RDKit::Bond::BondType> const *cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondType$get(::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Bond::BondType> *cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondType$release(::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondType$drop(::std::unique_ptr<::std::vector<::RDKit::Bond::BondType>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Bond::BondDir>::value, "definition of BondDir is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Bond::BondDir>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Bond::BondDir>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Bond$BondDir$null(::std::unique_ptr<::RDKit::Bond::BondDir> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondDir>();
}
::RDKit::Bond::BondDir *cxxbridge1$unique_ptr$RDKit$Bond$BondDir$uninit(::std::unique_ptr<::RDKit::Bond::BondDir> *ptr) noexcept {
  ::RDKit::Bond::BondDir *uninit = reinterpret_cast<::RDKit::Bond::BondDir *>(new ::rust::MaybeUninit<::RDKit::Bond::BondDir>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondDir>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Bond$BondDir$raw(::std::unique_ptr<::RDKit::Bond::BondDir> *ptr, ::RDKit::Bond::BondDir *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondDir>(raw);
}
::RDKit::Bond::BondDir const *cxxbridge1$unique_ptr$RDKit$Bond$BondDir$get(::std::unique_ptr<::RDKit::Bond::BondDir> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Bond::BondDir *cxxbridge1$unique_ptr$RDKit$Bond$BondDir$release(::std::unique_ptr<::RDKit::Bond::BondDir> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Bond$BondDir$drop(::std::unique_ptr<::RDKit::Bond::BondDir> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Bond::BondDir>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Bond::BondDir>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Bond::BondDir>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Bond$BondDir$null(::std::shared_ptr<::RDKit::Bond::BondDir> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondDir>();
}
::RDKit::Bond::BondDir *cxxbridge1$shared_ptr$RDKit$Bond$BondDir$uninit(::std::shared_ptr<::RDKit::Bond::BondDir> *ptr) noexcept {
  ::RDKit::Bond::BondDir *uninit = reinterpret_cast<::RDKit::Bond::BondDir *>(new ::rust::MaybeUninit<::RDKit::Bond::BondDir>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondDir>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Bond$BondDir$clone(::std::shared_ptr<::RDKit::Bond::BondDir> const &self, ::std::shared_ptr<::RDKit::Bond::BondDir> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondDir>(self);
}
::RDKit::Bond::BondDir const *cxxbridge1$shared_ptr$RDKit$Bond$BondDir$get(::std::shared_ptr<::RDKit::Bond::BondDir> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Bond$BondDir$drop(::std::shared_ptr<::RDKit::Bond::BondDir> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Bond::BondDir>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Bond::BondDir>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Bond$BondDir$null(::std::weak_ptr<::RDKit::Bond::BondDir> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Bond::BondDir>();
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondDir$clone(::std::weak_ptr<::RDKit::Bond::BondDir> const &self, ::std::weak_ptr<::RDKit::Bond::BondDir> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Bond::BondDir>(self);
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondDir$downgrade(::std::shared_ptr<::RDKit::Bond::BondDir> const &shared, ::std::weak_ptr<::RDKit::Bond::BondDir> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Bond::BondDir>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondDir$upgrade(::std::weak_ptr<::RDKit::Bond::BondDir> const &weak, ::std::shared_ptr<::RDKit::Bond::BondDir> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Bond::BondDir>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondDir$drop(::std::weak_ptr<::RDKit::Bond::BondDir> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Bond::BondDir> *cxxbridge1$std$vector$RDKit$Bond$BondDir$new() noexcept {
  return new ::std::vector<::RDKit::Bond::BondDir>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Bond$BondDir$size(::std::vector<::RDKit::Bond::BondDir> const &s) noexcept {
  return s.size();
}
::RDKit::Bond::BondDir *cxxbridge1$std$vector$RDKit$Bond$BondDir$get_unchecked(::std::vector<::RDKit::Bond::BondDir> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Bond$BondDir$push_back(::std::vector<::RDKit::Bond::BondDir> *v, ::RDKit::Bond::BondDir *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Bond$BondDir$pop_back(::std::vector<::RDKit::Bond::BondDir> *v, ::RDKit::Bond::BondDir *out) noexcept {
  ::new (out) ::RDKit::Bond::BondDir(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondDir$null(::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondDir$raw(::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>> *ptr, ::std::vector<::RDKit::Bond::BondDir> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>>(raw);
}
::std::vector<::RDKit::Bond::BondDir> const *cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondDir$get(::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Bond::BondDir> *cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondDir$release(::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondDir$drop(::std::unique_ptr<::std::vector<::RDKit::Bond::BondDir>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Bond::BondStereo>::value, "definition of BondStereo is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Bond::BondStereo>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Bond::BondStereo>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Bond$BondStereo$null(::std::unique_ptr<::RDKit::Bond::BondStereo> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondStereo>();
}
::RDKit::Bond::BondStereo *cxxbridge1$unique_ptr$RDKit$Bond$BondStereo$uninit(::std::unique_ptr<::RDKit::Bond::BondStereo> *ptr) noexcept {
  ::RDKit::Bond::BondStereo *uninit = reinterpret_cast<::RDKit::Bond::BondStereo *>(new ::rust::MaybeUninit<::RDKit::Bond::BondStereo>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondStereo>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Bond$BondStereo$raw(::std::unique_ptr<::RDKit::Bond::BondStereo> *ptr, ::RDKit::Bond::BondStereo *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Bond::BondStereo>(raw);
}
::RDKit::Bond::BondStereo const *cxxbridge1$unique_ptr$RDKit$Bond$BondStereo$get(::std::unique_ptr<::RDKit::Bond::BondStereo> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Bond::BondStereo *cxxbridge1$unique_ptr$RDKit$Bond$BondStereo$release(::std::unique_ptr<::RDKit::Bond::BondStereo> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Bond$BondStereo$drop(::std::unique_ptr<::RDKit::Bond::BondStereo> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Bond::BondStereo>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Bond::BondStereo>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Bond::BondStereo>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Bond$BondStereo$null(::std::shared_ptr<::RDKit::Bond::BondStereo> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondStereo>();
}
::RDKit::Bond::BondStereo *cxxbridge1$shared_ptr$RDKit$Bond$BondStereo$uninit(::std::shared_ptr<::RDKit::Bond::BondStereo> *ptr) noexcept {
  ::RDKit::Bond::BondStereo *uninit = reinterpret_cast<::RDKit::Bond::BondStereo *>(new ::rust::MaybeUninit<::RDKit::Bond::BondStereo>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondStereo>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Bond$BondStereo$clone(::std::shared_ptr<::RDKit::Bond::BondStereo> const &self, ::std::shared_ptr<::RDKit::Bond::BondStereo> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Bond::BondStereo>(self);
}
::RDKit::Bond::BondStereo const *cxxbridge1$shared_ptr$RDKit$Bond$BondStereo$get(::std::shared_ptr<::RDKit::Bond::BondStereo> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Bond$BondStereo$drop(::std::shared_ptr<::RDKit::Bond::BondStereo> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Bond::BondStereo>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Bond::BondStereo>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Bond$BondStereo$null(::std::weak_ptr<::RDKit::Bond::BondStereo> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Bond::BondStereo>();
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondStereo$clone(::std::weak_ptr<::RDKit::Bond::BondStereo> const &self, ::std::weak_ptr<::RDKit::Bond::BondStereo> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Bond::BondStereo>(self);
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondStereo$downgrade(::std::shared_ptr<::RDKit::Bond::BondStereo> const &shared, ::std::weak_ptr<::RDKit::Bond::BondStereo> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Bond::BondStereo>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondStereo$upgrade(::std::weak_ptr<::RDKit::Bond::BondStereo> const &weak, ::std::shared_ptr<::RDKit::Bond::BondStereo> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Bond::BondStereo>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Bond$BondStereo$drop(::std::weak_ptr<::RDKit::Bond::BondStereo> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Bond::BondStereo> *cxxbridge1$std$vector$RDKit$Bond$BondStereo$new() noexcept {
  return new ::std::vector<::RDKit::Bond::BondStereo>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Bond$BondStereo$size(::std::vector<::RDKit::Bond::BondStereo> const &s) noexcept {
  return s.size();
}
::RDKit::Bond::BondStereo *cxxbridge1$std$vector$RDKit$Bond$BondStereo$get_unchecked(::std::vector<::RDKit::Bond::BondStereo> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Bond$BondStereo$push_back(::std::vector<::RDKit::Bond::BondStereo> *v, ::RDKit::Bond::BondStereo *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Bond$BondStereo$pop_back(::std::vector<::RDKit::Bond::BondStereo> *v, ::RDKit::Bond::BondStereo *out) noexcept {
  ::new (out) ::RDKit::Bond::BondStereo(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondStereo$null(::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondStereo$raw(::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>> *ptr, ::std::vector<::RDKit::Bond::BondStereo> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>>(raw);
}
::std::vector<::RDKit::Bond::BondStereo> const *cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondStereo$get(::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Bond::BondStereo> *cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondStereo$release(::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Bond$BondStereo$drop(::std::unique_ptr<::std::vector<::RDKit::Bond::BondStereo>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::ConformerException>::value, "definition of ConformerException is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::ConformerException>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::ConformerException>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$ConformerException$null(::std::unique_ptr<::RDKit::ConformerException> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::ConformerException>();
}
::RDKit::ConformerException *cxxbridge1$unique_ptr$RDKit$ConformerException$uninit(::std::unique_ptr<::RDKit::ConformerException> *ptr) noexcept {
  ::RDKit::ConformerException *uninit = reinterpret_cast<::RDKit::ConformerException *>(new ::rust::MaybeUninit<::RDKit::ConformerException>);
  ::new (ptr) ::std::unique_ptr<::RDKit::ConformerException>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$ConformerException$raw(::std::unique_ptr<::RDKit::ConformerException> *ptr, ::RDKit::ConformerException *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::ConformerException>(raw);
}
::RDKit::ConformerException const *cxxbridge1$unique_ptr$RDKit$ConformerException$get(::std::unique_ptr<::RDKit::ConformerException> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::ConformerException *cxxbridge1$unique_ptr$RDKit$ConformerException$release(::std::unique_ptr<::RDKit::ConformerException> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$ConformerException$drop(::std::unique_ptr<::RDKit::ConformerException> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::ConformerException>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::ConformerException>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::ConformerException>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$ConformerException$null(::std::shared_ptr<::RDKit::ConformerException> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::ConformerException>();
}
::RDKit::ConformerException *cxxbridge1$shared_ptr$RDKit$ConformerException$uninit(::std::shared_ptr<::RDKit::ConformerException> *ptr) noexcept {
  ::RDKit::ConformerException *uninit = reinterpret_cast<::RDKit::ConformerException *>(new ::rust::MaybeUninit<::RDKit::ConformerException>);
  ::new (ptr) ::std::shared_ptr<::RDKit::ConformerException>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$ConformerException$clone(::std::shared_ptr<::RDKit::ConformerException> const &self, ::std::shared_ptr<::RDKit::ConformerException> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::ConformerException>(self);
}
::RDKit::ConformerException const *cxxbridge1$shared_ptr$RDKit$ConformerException$get(::std::shared_ptr<::RDKit::ConformerException> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$ConformerException$drop(::std::shared_ptr<::RDKit::ConformerException> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::ConformerException>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::ConformerException>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$ConformerException$null(::std::weak_ptr<::RDKit::ConformerException> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::ConformerException>();
}
void cxxbridge1$weak_ptr$RDKit$ConformerException$clone(::std::weak_ptr<::RDKit::ConformerException> const &self, ::std::weak_ptr<::RDKit::ConformerException> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::ConformerException>(self);
}
void cxxbridge1$weak_ptr$RDKit$ConformerException$downgrade(::std::shared_ptr<::RDKit::ConformerException> const &shared, ::std::weak_ptr<::RDKit::ConformerException> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::ConformerException>(shared);
}
void cxxbridge1$weak_ptr$RDKit$ConformerException$upgrade(::std::weak_ptr<::RDKit::ConformerException> const &weak, ::std::shared_ptr<::RDKit::ConformerException> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::ConformerException>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$ConformerException$drop(::std::weak_ptr<::RDKit::ConformerException> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::Conformer>::value, "definition of Conformer is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::Conformer>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::Conformer>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$Conformer$null(::std::unique_ptr<::RDKit::Conformer> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Conformer>();
}
::RDKit::Conformer *cxxbridge1$unique_ptr$RDKit$Conformer$uninit(::std::unique_ptr<::RDKit::Conformer> *ptr) noexcept {
  ::RDKit::Conformer *uninit = reinterpret_cast<::RDKit::Conformer *>(new ::rust::MaybeUninit<::RDKit::Conformer>);
  ::new (ptr) ::std::unique_ptr<::RDKit::Conformer>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$Conformer$raw(::std::unique_ptr<::RDKit::Conformer> *ptr, ::RDKit::Conformer *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::Conformer>(raw);
}
::RDKit::Conformer const *cxxbridge1$unique_ptr$RDKit$Conformer$get(::std::unique_ptr<::RDKit::Conformer> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::Conformer *cxxbridge1$unique_ptr$RDKit$Conformer$release(::std::unique_ptr<::RDKit::Conformer> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$Conformer$drop(::std::unique_ptr<::RDKit::Conformer> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::Conformer>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::Conformer>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::Conformer>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$Conformer$null(::std::shared_ptr<::RDKit::Conformer> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Conformer>();
}
::RDKit::Conformer *cxxbridge1$shared_ptr$RDKit$Conformer$uninit(::std::shared_ptr<::RDKit::Conformer> *ptr) noexcept {
  ::RDKit::Conformer *uninit = reinterpret_cast<::RDKit::Conformer *>(new ::rust::MaybeUninit<::RDKit::Conformer>);
  ::new (ptr) ::std::shared_ptr<::RDKit::Conformer>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$Conformer$clone(::std::shared_ptr<::RDKit::Conformer> const &self, ::std::shared_ptr<::RDKit::Conformer> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::Conformer>(self);
}
::RDKit::Conformer const *cxxbridge1$shared_ptr$RDKit$Conformer$get(::std::shared_ptr<::RDKit::Conformer> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$Conformer$drop(::std::shared_ptr<::RDKit::Conformer> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::Conformer>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::Conformer>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$Conformer$null(::std::weak_ptr<::RDKit::Conformer> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Conformer>();
}
void cxxbridge1$weak_ptr$RDKit$Conformer$clone(::std::weak_ptr<::RDKit::Conformer> const &self, ::std::weak_ptr<::RDKit::Conformer> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::Conformer>(self);
}
void cxxbridge1$weak_ptr$RDKit$Conformer$downgrade(::std::shared_ptr<::RDKit::Conformer> const &shared, ::std::weak_ptr<::RDKit::Conformer> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::Conformer>(shared);
}
void cxxbridge1$weak_ptr$RDKit$Conformer$upgrade(::std::weak_ptr<::RDKit::Conformer> const &weak, ::std::shared_ptr<::RDKit::Conformer> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::Conformer>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$Conformer$drop(::std::weak_ptr<::RDKit::Conformer> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::Conformer> *cxxbridge1$std$vector$RDKit$Conformer$new() noexcept {
  return new ::std::vector<::RDKit::Conformer>();
}
::std::size_t cxxbridge1$std$vector$RDKit$Conformer$size(::std::vector<::RDKit::Conformer> const &s) noexcept {
  return s.size();
}
::RDKit::Conformer *cxxbridge1$std$vector$RDKit$Conformer$get_unchecked(::std::vector<::RDKit::Conformer> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$Conformer$push_back(::std::vector<::RDKit::Conformer> *v, ::RDKit::Conformer *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$Conformer$pop_back(::std::vector<::RDKit::Conformer> *v, ::RDKit::Conformer *out) noexcept {
  ::new (out) ::RDKit::Conformer(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::Conformer>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::Conformer>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$Conformer$null(::std::unique_ptr<::std::vector<::RDKit::Conformer>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Conformer>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Conformer$raw(::std::unique_ptr<::std::vector<::RDKit::Conformer>> *ptr, ::std::vector<::RDKit::Conformer> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::Conformer>>(raw);
}
::std::vector<::RDKit::Conformer> const *cxxbridge1$unique_ptr$std$vector$RDKit$Conformer$get(::std::unique_ptr<::std::vector<::RDKit::Conformer>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::Conformer> *cxxbridge1$unique_ptr$std$vector$RDKit$Conformer$release(::std::unique_ptr<::std::vector<::RDKit::Conformer>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$Conformer$drop(::std::unique_ptr<::std::vector<::RDKit::Conformer>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::SubstanceGroupException>::value, "definition of SubstanceGroupException is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::SubstanceGroupException>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::SubstanceGroupException>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$SubstanceGroupException$null(::std::unique_ptr<::RDKit::SubstanceGroupException> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroupException>();
}
::RDKit::SubstanceGroupException *cxxbridge1$unique_ptr$RDKit$SubstanceGroupException$uninit(::std::unique_ptr<::RDKit::SubstanceGroupException> *ptr) noexcept {
  ::RDKit::SubstanceGroupException *uninit = reinterpret_cast<::RDKit::SubstanceGroupException *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroupException>);
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroupException>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroupException$raw(::std::unique_ptr<::RDKit::SubstanceGroupException> *ptr, ::RDKit::SubstanceGroupException *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroupException>(raw);
}
::RDKit::SubstanceGroupException const *cxxbridge1$unique_ptr$RDKit$SubstanceGroupException$get(::std::unique_ptr<::RDKit::SubstanceGroupException> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::SubstanceGroupException *cxxbridge1$unique_ptr$RDKit$SubstanceGroupException$release(::std::unique_ptr<::RDKit::SubstanceGroupException> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroupException$drop(::std::unique_ptr<::RDKit::SubstanceGroupException> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::SubstanceGroupException>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::SubstanceGroupException>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::SubstanceGroupException>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$SubstanceGroupException$null(::std::shared_ptr<::RDKit::SubstanceGroupException> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroupException>();
}
::RDKit::SubstanceGroupException *cxxbridge1$shared_ptr$RDKit$SubstanceGroupException$uninit(::std::shared_ptr<::RDKit::SubstanceGroupException> *ptr) noexcept {
  ::RDKit::SubstanceGroupException *uninit = reinterpret_cast<::RDKit::SubstanceGroupException *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroupException>);
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroupException>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroupException$clone(::std::shared_ptr<::RDKit::SubstanceGroupException> const &self, ::std::shared_ptr<::RDKit::SubstanceGroupException> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroupException>(self);
}
::RDKit::SubstanceGroupException const *cxxbridge1$shared_ptr$RDKit$SubstanceGroupException$get(::std::shared_ptr<::RDKit::SubstanceGroupException> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroupException$drop(::std::shared_ptr<::RDKit::SubstanceGroupException> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::SubstanceGroupException>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::SubstanceGroupException>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$SubstanceGroupException$null(::std::weak_ptr<::RDKit::SubstanceGroupException> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroupException>();
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroupException$clone(::std::weak_ptr<::RDKit::SubstanceGroupException> const &self, ::std::weak_ptr<::RDKit::SubstanceGroupException> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroupException>(self);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroupException$downgrade(::std::shared_ptr<::RDKit::SubstanceGroupException> const &shared, ::std::weak_ptr<::RDKit::SubstanceGroupException> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::SubstanceGroupException>(shared);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroupException$upgrade(::std::weak_ptr<::RDKit::SubstanceGroupException> const &weak, ::std::shared_ptr<::RDKit::SubstanceGroupException> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::SubstanceGroupException>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroupException$drop(::std::weak_ptr<::RDKit::SubstanceGroupException> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::SubstanceGroup>::value, "definition of SubstanceGroup is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::SubstanceGroup>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::SubstanceGroup>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$null(::std::unique_ptr<::RDKit::SubstanceGroup> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup>();
}
::RDKit::SubstanceGroup *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$uninit(::std::unique_ptr<::RDKit::SubstanceGroup> *ptr) noexcept {
  ::RDKit::SubstanceGroup *uninit = reinterpret_cast<::RDKit::SubstanceGroup *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroup>);
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$raw(::std::unique_ptr<::RDKit::SubstanceGroup> *ptr, ::RDKit::SubstanceGroup *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup>(raw);
}
::RDKit::SubstanceGroup const *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$get(::std::unique_ptr<::RDKit::SubstanceGroup> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::SubstanceGroup *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$release(::std::unique_ptr<::RDKit::SubstanceGroup> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$drop(::std::unique_ptr<::RDKit::SubstanceGroup> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::SubstanceGroup>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::SubstanceGroup>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::SubstanceGroup>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$null(::std::shared_ptr<::RDKit::SubstanceGroup> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup>();
}
::RDKit::SubstanceGroup *cxxbridge1$shared_ptr$RDKit$SubstanceGroup$uninit(::std::shared_ptr<::RDKit::SubstanceGroup> *ptr) noexcept {
  ::RDKit::SubstanceGroup *uninit = reinterpret_cast<::RDKit::SubstanceGroup *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroup>);
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$clone(::std::shared_ptr<::RDKit::SubstanceGroup> const &self, ::std::shared_ptr<::RDKit::SubstanceGroup> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup>(self);
}
::RDKit::SubstanceGroup const *cxxbridge1$shared_ptr$RDKit$SubstanceGroup$get(::std::shared_ptr<::RDKit::SubstanceGroup> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$drop(::std::shared_ptr<::RDKit::SubstanceGroup> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::SubstanceGroup>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::SubstanceGroup>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$null(::std::weak_ptr<::RDKit::SubstanceGroup> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroup>();
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$clone(::std::weak_ptr<::RDKit::SubstanceGroup> const &self, ::std::weak_ptr<::RDKit::SubstanceGroup> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroup>(self);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$downgrade(::std::shared_ptr<::RDKit::SubstanceGroup> const &shared, ::std::weak_ptr<::RDKit::SubstanceGroup> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::SubstanceGroup>(shared);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$upgrade(::std::weak_ptr<::RDKit::SubstanceGroup> const &weak, ::std::shared_ptr<::RDKit::SubstanceGroup> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::SubstanceGroup>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$drop(::std::weak_ptr<::RDKit::SubstanceGroup> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::SubstanceGroup> *cxxbridge1$std$vector$RDKit$SubstanceGroup$new() noexcept {
  return new ::std::vector<::RDKit::SubstanceGroup>();
}
::std::size_t cxxbridge1$std$vector$RDKit$SubstanceGroup$size(::std::vector<::RDKit::SubstanceGroup> const &s) noexcept {
  return s.size();
}
::RDKit::SubstanceGroup *cxxbridge1$std$vector$RDKit$SubstanceGroup$get_unchecked(::std::vector<::RDKit::SubstanceGroup> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$SubstanceGroup$push_back(::std::vector<::RDKit::SubstanceGroup> *v, ::RDKit::SubstanceGroup *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$SubstanceGroup$pop_back(::std::vector<::RDKit::SubstanceGroup> *v, ::RDKit::SubstanceGroup *out) noexcept {
  ::new (out) ::RDKit::SubstanceGroup(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$null(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$raw(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>> *ptr, ::std::vector<::RDKit::SubstanceGroup> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>>(raw);
}
::std::vector<::RDKit::SubstanceGroup> const *cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$get(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::SubstanceGroup> *cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$release(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$drop(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::SubstanceGroup::BondType>::value, "definition of BondType is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::SubstanceGroup::BondType>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::SubstanceGroup::BondType>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$BondType$null(::std::unique_ptr<::RDKit::SubstanceGroup::BondType> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::BondType>();
}
::RDKit::SubstanceGroup::BondType *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$BondType$uninit(::std::unique_ptr<::RDKit::SubstanceGroup::BondType> *ptr) noexcept {
  ::RDKit::SubstanceGroup::BondType *uninit = reinterpret_cast<::RDKit::SubstanceGroup::BondType *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroup::BondType>);
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::BondType>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$BondType$raw(::std::unique_ptr<::RDKit::SubstanceGroup::BondType> *ptr, ::RDKit::SubstanceGroup::BondType *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::BondType>(raw);
}
::RDKit::SubstanceGroup::BondType const *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$BondType$get(::std::unique_ptr<::RDKit::SubstanceGroup::BondType> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::SubstanceGroup::BondType *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$BondType$release(::std::unique_ptr<::RDKit::SubstanceGroup::BondType> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$BondType$drop(::std::unique_ptr<::RDKit::SubstanceGroup::BondType> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::SubstanceGroup::BondType>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::SubstanceGroup::BondType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::SubstanceGroup::BondType>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$BondType$null(::std::shared_ptr<::RDKit::SubstanceGroup::BondType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::BondType>();
}
::RDKit::SubstanceGroup::BondType *cxxbridge1$shared_ptr$RDKit$SubstanceGroup$BondType$uninit(::std::shared_ptr<::RDKit::SubstanceGroup::BondType> *ptr) noexcept {
  ::RDKit::SubstanceGroup::BondType *uninit = reinterpret_cast<::RDKit::SubstanceGroup::BondType *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroup::BondType>);
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::BondType>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$BondType$clone(::std::shared_ptr<::RDKit::SubstanceGroup::BondType> const &self, ::std::shared_ptr<::RDKit::SubstanceGroup::BondType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::BondType>(self);
}
::RDKit::SubstanceGroup::BondType const *cxxbridge1$shared_ptr$RDKit$SubstanceGroup$BondType$get(::std::shared_ptr<::RDKit::SubstanceGroup::BondType> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$BondType$drop(::std::shared_ptr<::RDKit::SubstanceGroup::BondType> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::SubstanceGroup::BondType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::SubstanceGroup::BondType>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$BondType$null(::std::weak_ptr<::RDKit::SubstanceGroup::BondType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroup::BondType>();
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$BondType$clone(::std::weak_ptr<::RDKit::SubstanceGroup::BondType> const &self, ::std::weak_ptr<::RDKit::SubstanceGroup::BondType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroup::BondType>(self);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$BondType$downgrade(::std::shared_ptr<::RDKit::SubstanceGroup::BondType> const &shared, ::std::weak_ptr<::RDKit::SubstanceGroup::BondType> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::SubstanceGroup::BondType>(shared);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$BondType$upgrade(::std::weak_ptr<::RDKit::SubstanceGroup::BondType> const &weak, ::std::shared_ptr<::RDKit::SubstanceGroup::BondType> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::SubstanceGroup::BondType>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$BondType$drop(::std::weak_ptr<::RDKit::SubstanceGroup::BondType> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::SubstanceGroup::BondType> *cxxbridge1$std$vector$RDKit$SubstanceGroup$BondType$new() noexcept {
  return new ::std::vector<::RDKit::SubstanceGroup::BondType>();
}
::std::size_t cxxbridge1$std$vector$RDKit$SubstanceGroup$BondType$size(::std::vector<::RDKit::SubstanceGroup::BondType> const &s) noexcept {
  return s.size();
}
::RDKit::SubstanceGroup::BondType *cxxbridge1$std$vector$RDKit$SubstanceGroup$BondType$get_unchecked(::std::vector<::RDKit::SubstanceGroup::BondType> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$SubstanceGroup$BondType$push_back(::std::vector<::RDKit::SubstanceGroup::BondType> *v, ::RDKit::SubstanceGroup::BondType *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$SubstanceGroup$BondType$pop_back(::std::vector<::RDKit::SubstanceGroup::BondType> *v, ::RDKit::SubstanceGroup::BondType *out) noexcept {
  ::new (out) ::RDKit::SubstanceGroup::BondType(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$BondType$null(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$BondType$raw(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>> *ptr, ::std::vector<::RDKit::SubstanceGroup::BondType> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>>(raw);
}
::std::vector<::RDKit::SubstanceGroup::BondType> const *cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$BondType$get(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::SubstanceGroup::BondType> *cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$BondType$release(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$BondType$drop(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::BondType>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::SubstanceGroup::AttachPoint>::value, "definition of AttachPoint is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$AttachPoint$null(::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint>();
}
::RDKit::SubstanceGroup::AttachPoint *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$AttachPoint$uninit(::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr) noexcept {
  ::RDKit::SubstanceGroup::AttachPoint *uninit = reinterpret_cast<::RDKit::SubstanceGroup::AttachPoint *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroup::AttachPoint>);
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$AttachPoint$raw(::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr, ::RDKit::SubstanceGroup::AttachPoint *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint>(raw);
}
::RDKit::SubstanceGroup::AttachPoint const *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$AttachPoint$get(::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::SubstanceGroup::AttachPoint *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$AttachPoint$release(::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$AttachPoint$drop(::std::unique_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::SubstanceGroup::AttachPoint>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$AttachPoint$null(::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint>();
}
::RDKit::SubstanceGroup::AttachPoint *cxxbridge1$shared_ptr$RDKit$SubstanceGroup$AttachPoint$uninit(::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr) noexcept {
  ::RDKit::SubstanceGroup::AttachPoint *uninit = reinterpret_cast<::RDKit::SubstanceGroup::AttachPoint *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroup::AttachPoint>);
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$AttachPoint$clone(::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint> const &self, ::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint>(self);
}
::RDKit::SubstanceGroup::AttachPoint const *cxxbridge1$shared_ptr$RDKit$SubstanceGroup$AttachPoint$get(::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$AttachPoint$drop(::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$AttachPoint$null(::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint>();
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$AttachPoint$clone(::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint> const &self, ::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint>(self);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$AttachPoint$downgrade(::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint> const &shared, ::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint>(shared);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$AttachPoint$upgrade(::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint> const &weak, ::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::SubstanceGroup::AttachPoint>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$AttachPoint$drop(::std::weak_ptr<::RDKit::SubstanceGroup::AttachPoint> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::SubstanceGroup::AttachPoint> *cxxbridge1$std$vector$RDKit$SubstanceGroup$AttachPoint$new() noexcept {
  return new ::std::vector<::RDKit::SubstanceGroup::AttachPoint>();
}
::std::size_t cxxbridge1$std$vector$RDKit$SubstanceGroup$AttachPoint$size(::std::vector<::RDKit::SubstanceGroup::AttachPoint> const &s) noexcept {
  return s.size();
}
::RDKit::SubstanceGroup::AttachPoint *cxxbridge1$std$vector$RDKit$SubstanceGroup$AttachPoint$get_unchecked(::std::vector<::RDKit::SubstanceGroup::AttachPoint> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$SubstanceGroup$AttachPoint$push_back(::std::vector<::RDKit::SubstanceGroup::AttachPoint> *v, ::RDKit::SubstanceGroup::AttachPoint *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$SubstanceGroup$AttachPoint$pop_back(::std::vector<::RDKit::SubstanceGroup::AttachPoint> *v, ::RDKit::SubstanceGroup::AttachPoint *out) noexcept {
  ::new (out) ::RDKit::SubstanceGroup::AttachPoint(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$AttachPoint$null(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$AttachPoint$raw(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>> *ptr, ::std::vector<::RDKit::SubstanceGroup::AttachPoint> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>>(raw);
}
::std::vector<::RDKit::SubstanceGroup::AttachPoint> const *cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$AttachPoint$get(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::SubstanceGroup::AttachPoint> *cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$AttachPoint$release(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$SubstanceGroup$AttachPoint$drop(::std::unique_ptr<::std::vector<::RDKit::SubstanceGroup::AttachPoint>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::SubstanceGroup::CState>::value, "definition of CState is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::SubstanceGroup::CState>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::SubstanceGroup::CState>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$CState$null(::std::unique_ptr<::RDKit::SubstanceGroup::CState> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::CState>();
}
::RDKit::SubstanceGroup::CState *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$CState$uninit(::std::unique_ptr<::RDKit::SubstanceGroup::CState> *ptr) noexcept {
  ::RDKit::SubstanceGroup::CState *uninit = reinterpret_cast<::RDKit::SubstanceGroup::CState *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroup::CState>);
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::CState>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$CState$raw(::std::unique_ptr<::RDKit::SubstanceGroup::CState> *ptr, ::RDKit::SubstanceGroup::CState *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::SubstanceGroup::CState>(raw);
}
::RDKit::SubstanceGroup::CState const *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$CState$get(::std::unique_ptr<::RDKit::SubstanceGroup::CState> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::SubstanceGroup::CState *cxxbridge1$unique_ptr$RDKit$SubstanceGroup$CState$release(::std::unique_ptr<::RDKit::SubstanceGroup::CState> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$SubstanceGroup$CState$drop(::std::unique_ptr<::RDKit::SubstanceGroup::CState> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::SubstanceGroup::CState>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::SubstanceGroup::CState>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::SubstanceGroup::CState>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$CState$null(::std::shared_ptr<::RDKit::SubstanceGroup::CState> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::CState>();
}
::RDKit::SubstanceGroup::CState *cxxbridge1$shared_ptr$RDKit$SubstanceGroup$CState$uninit(::std::shared_ptr<::RDKit::SubstanceGroup::CState> *ptr) noexcept {
  ::RDKit::SubstanceGroup::CState *uninit = reinterpret_cast<::RDKit::SubstanceGroup::CState *>(new ::rust::MaybeUninit<::RDKit::SubstanceGroup::CState>);
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::CState>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$CState$clone(::std::shared_ptr<::RDKit::SubstanceGroup::CState> const &self, ::std::shared_ptr<::RDKit::SubstanceGroup::CState> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::SubstanceGroup::CState>(self);
}
::RDKit::SubstanceGroup::CState const *cxxbridge1$shared_ptr$RDKit$SubstanceGroup$CState$get(::std::shared_ptr<::RDKit::SubstanceGroup::CState> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$SubstanceGroup$CState$drop(::std::shared_ptr<::RDKit::SubstanceGroup::CState> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::SubstanceGroup::CState>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::SubstanceGroup::CState>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$CState$null(::std::weak_ptr<::RDKit::SubstanceGroup::CState> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroup::CState>();
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$CState$clone(::std::weak_ptr<::RDKit::SubstanceGroup::CState> const &self, ::std::weak_ptr<::RDKit::SubstanceGroup::CState> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::SubstanceGroup::CState>(self);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$CState$downgrade(::std::shared_ptr<::RDKit::SubstanceGroup::CState> const &shared, ::std::weak_ptr<::RDKit::SubstanceGroup::CState> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::SubstanceGroup::CState>(shared);
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$CState$upgrade(::std::weak_ptr<::RDKit::SubstanceGroup::CState> const &weak, ::std::shared_ptr<::RDKit::SubstanceGroup::CState> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::SubstanceGroup::CState>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$SubstanceGroup$CState$drop(::std::weak_ptr<::RDKit::SubstanceGroup::CState> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::StereoGroupType>::value, "definition of StereoGroupType is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::StereoGroupType>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::StereoGroupType>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$StereoGroupType$null(::std::unique_ptr<::RDKit::StereoGroupType> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::StereoGroupType>();
}
::RDKit::StereoGroupType *cxxbridge1$unique_ptr$RDKit$StereoGroupType$uninit(::std::unique_ptr<::RDKit::StereoGroupType> *ptr) noexcept {
  ::RDKit::StereoGroupType *uninit = reinterpret_cast<::RDKit::StereoGroupType *>(new ::rust::MaybeUninit<::RDKit::StereoGroupType>);
  ::new (ptr) ::std::unique_ptr<::RDKit::StereoGroupType>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$StereoGroupType$raw(::std::unique_ptr<::RDKit::StereoGroupType> *ptr, ::RDKit::StereoGroupType *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::StereoGroupType>(raw);
}
::RDKit::StereoGroupType const *cxxbridge1$unique_ptr$RDKit$StereoGroupType$get(::std::unique_ptr<::RDKit::StereoGroupType> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::StereoGroupType *cxxbridge1$unique_ptr$RDKit$StereoGroupType$release(::std::unique_ptr<::RDKit::StereoGroupType> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$StereoGroupType$drop(::std::unique_ptr<::RDKit::StereoGroupType> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::StereoGroupType>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::StereoGroupType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::StereoGroupType>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$StereoGroupType$null(::std::shared_ptr<::RDKit::StereoGroupType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::StereoGroupType>();
}
::RDKit::StereoGroupType *cxxbridge1$shared_ptr$RDKit$StereoGroupType$uninit(::std::shared_ptr<::RDKit::StereoGroupType> *ptr) noexcept {
  ::RDKit::StereoGroupType *uninit = reinterpret_cast<::RDKit::StereoGroupType *>(new ::rust::MaybeUninit<::RDKit::StereoGroupType>);
  ::new (ptr) ::std::shared_ptr<::RDKit::StereoGroupType>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$StereoGroupType$clone(::std::shared_ptr<::RDKit::StereoGroupType> const &self, ::std::shared_ptr<::RDKit::StereoGroupType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::StereoGroupType>(self);
}
::RDKit::StereoGroupType const *cxxbridge1$shared_ptr$RDKit$StereoGroupType$get(::std::shared_ptr<::RDKit::StereoGroupType> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$StereoGroupType$drop(::std::shared_ptr<::RDKit::StereoGroupType> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::StereoGroupType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::StereoGroupType>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$StereoGroupType$null(::std::weak_ptr<::RDKit::StereoGroupType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::StereoGroupType>();
}
void cxxbridge1$weak_ptr$RDKit$StereoGroupType$clone(::std::weak_ptr<::RDKit::StereoGroupType> const &self, ::std::weak_ptr<::RDKit::StereoGroupType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::StereoGroupType>(self);
}
void cxxbridge1$weak_ptr$RDKit$StereoGroupType$downgrade(::std::shared_ptr<::RDKit::StereoGroupType> const &shared, ::std::weak_ptr<::RDKit::StereoGroupType> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::StereoGroupType>(shared);
}
void cxxbridge1$weak_ptr$RDKit$StereoGroupType$upgrade(::std::weak_ptr<::RDKit::StereoGroupType> const &weak, ::std::shared_ptr<::RDKit::StereoGroupType> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::StereoGroupType>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$StereoGroupType$drop(::std::weak_ptr<::RDKit::StereoGroupType> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::StereoGroupType> *cxxbridge1$std$vector$RDKit$StereoGroupType$new() noexcept {
  return new ::std::vector<::RDKit::StereoGroupType>();
}
::std::size_t cxxbridge1$std$vector$RDKit$StereoGroupType$size(::std::vector<::RDKit::StereoGroupType> const &s) noexcept {
  return s.size();
}
::RDKit::StereoGroupType *cxxbridge1$std$vector$RDKit$StereoGroupType$get_unchecked(::std::vector<::RDKit::StereoGroupType> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$StereoGroupType$push_back(::std::vector<::RDKit::StereoGroupType> *v, ::RDKit::StereoGroupType *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$StereoGroupType$pop_back(::std::vector<::RDKit::StereoGroupType> *v, ::RDKit::StereoGroupType *out) noexcept {
  ::new (out) ::RDKit::StereoGroupType(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroupType$null(::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroupType$raw(::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>> *ptr, ::std::vector<::RDKit::StereoGroupType> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>>(raw);
}
::std::vector<::RDKit::StereoGroupType> const *cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroupType$get(::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::StereoGroupType> *cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroupType$release(::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroupType$drop(::std::unique_ptr<::std::vector<::RDKit::StereoGroupType>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::StereoGroup>::value, "definition of StereoGroup is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::StereoGroup>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::StereoGroup>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$StereoGroup$null(::std::unique_ptr<::RDKit::StereoGroup> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::StereoGroup>();
}
::RDKit::StereoGroup *cxxbridge1$unique_ptr$RDKit$StereoGroup$uninit(::std::unique_ptr<::RDKit::StereoGroup> *ptr) noexcept {
  ::RDKit::StereoGroup *uninit = reinterpret_cast<::RDKit::StereoGroup *>(new ::rust::MaybeUninit<::RDKit::StereoGroup>);
  ::new (ptr) ::std::unique_ptr<::RDKit::StereoGroup>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$StereoGroup$raw(::std::unique_ptr<::RDKit::StereoGroup> *ptr, ::RDKit::StereoGroup *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::StereoGroup>(raw);
}
::RDKit::StereoGroup const *cxxbridge1$unique_ptr$RDKit$StereoGroup$get(::std::unique_ptr<::RDKit::StereoGroup> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::StereoGroup *cxxbridge1$unique_ptr$RDKit$StereoGroup$release(::std::unique_ptr<::RDKit::StereoGroup> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$StereoGroup$drop(::std::unique_ptr<::RDKit::StereoGroup> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::StereoGroup>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::StereoGroup>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::StereoGroup>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$StereoGroup$null(::std::shared_ptr<::RDKit::StereoGroup> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::StereoGroup>();
}
::RDKit::StereoGroup *cxxbridge1$shared_ptr$RDKit$StereoGroup$uninit(::std::shared_ptr<::RDKit::StereoGroup> *ptr) noexcept {
  ::RDKit::StereoGroup *uninit = reinterpret_cast<::RDKit::StereoGroup *>(new ::rust::MaybeUninit<::RDKit::StereoGroup>);
  ::new (ptr) ::std::shared_ptr<::RDKit::StereoGroup>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$StereoGroup$clone(::std::shared_ptr<::RDKit::StereoGroup> const &self, ::std::shared_ptr<::RDKit::StereoGroup> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::StereoGroup>(self);
}
::RDKit::StereoGroup const *cxxbridge1$shared_ptr$RDKit$StereoGroup$get(::std::shared_ptr<::RDKit::StereoGroup> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$StereoGroup$drop(::std::shared_ptr<::RDKit::StereoGroup> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::StereoGroup>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::StereoGroup>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$StereoGroup$null(::std::weak_ptr<::RDKit::StereoGroup> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::StereoGroup>();
}
void cxxbridge1$weak_ptr$RDKit$StereoGroup$clone(::std::weak_ptr<::RDKit::StereoGroup> const &self, ::std::weak_ptr<::RDKit::StereoGroup> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::StereoGroup>(self);
}
void cxxbridge1$weak_ptr$RDKit$StereoGroup$downgrade(::std::shared_ptr<::RDKit::StereoGroup> const &shared, ::std::weak_ptr<::RDKit::StereoGroup> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::StereoGroup>(shared);
}
void cxxbridge1$weak_ptr$RDKit$StereoGroup$upgrade(::std::weak_ptr<::RDKit::StereoGroup> const &weak, ::std::shared_ptr<::RDKit::StereoGroup> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::StereoGroup>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$StereoGroup$drop(::std::weak_ptr<::RDKit::StereoGroup> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::StereoGroup> *cxxbridge1$std$vector$RDKit$StereoGroup$new() noexcept {
  return new ::std::vector<::RDKit::StereoGroup>();
}
::std::size_t cxxbridge1$std$vector$RDKit$StereoGroup$size(::std::vector<::RDKit::StereoGroup> const &s) noexcept {
  return s.size();
}
::RDKit::StereoGroup *cxxbridge1$std$vector$RDKit$StereoGroup$get_unchecked(::std::vector<::RDKit::StereoGroup> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$StereoGroup$push_back(::std::vector<::RDKit::StereoGroup> *v, ::RDKit::StereoGroup *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$StereoGroup$pop_back(::std::vector<::RDKit::StereoGroup> *v, ::RDKit::StereoGroup *out) noexcept {
  ::new (out) ::RDKit::StereoGroup(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::StereoGroup>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::StereoGroup>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroup$null(::std::unique_ptr<::std::vector<::RDKit::StereoGroup>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::StereoGroup>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroup$raw(::std::unique_ptr<::std::vector<::RDKit::StereoGroup>> *ptr, ::std::vector<::RDKit::StereoGroup> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::StereoGroup>>(raw);
}
::std::vector<::RDKit::StereoGroup> const *cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroup$get(::std::unique_ptr<::std::vector<::RDKit::StereoGroup>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::StereoGroup> *cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroup$release(::std::unique_ptr<::std::vector<::RDKit::StereoGroup>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$StereoGroup$drop(::std::unique_ptr<::std::vector<::RDKit::StereoGroup>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::RingInfo>::value, "definition of RingInfo is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::RingInfo>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::RingInfo>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$RingInfo$null(::std::unique_ptr<::RDKit::RingInfo> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RingInfo>();
}
::RDKit::RingInfo *cxxbridge1$unique_ptr$RDKit$RingInfo$uninit(::std::unique_ptr<::RDKit::RingInfo> *ptr) noexcept {
  ::RDKit::RingInfo *uninit = reinterpret_cast<::RDKit::RingInfo *>(new ::rust::MaybeUninit<::RDKit::RingInfo>);
  ::new (ptr) ::std::unique_ptr<::RDKit::RingInfo>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$RingInfo$raw(::std::unique_ptr<::RDKit::RingInfo> *ptr, ::RDKit::RingInfo *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::RingInfo>(raw);
}
::RDKit::RingInfo const *cxxbridge1$unique_ptr$RDKit$RingInfo$get(::std::unique_ptr<::RDKit::RingInfo> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::RingInfo *cxxbridge1$unique_ptr$RDKit$RingInfo$release(::std::unique_ptr<::RDKit::RingInfo> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$RingInfo$drop(::std::unique_ptr<::RDKit::RingInfo> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::RingInfo>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::RingInfo>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::RingInfo>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$RingInfo$null(::std::shared_ptr<::RDKit::RingInfo> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RingInfo>();
}
::RDKit::RingInfo *cxxbridge1$shared_ptr$RDKit$RingInfo$uninit(::std::shared_ptr<::RDKit::RingInfo> *ptr) noexcept {
  ::RDKit::RingInfo *uninit = reinterpret_cast<::RDKit::RingInfo *>(new ::rust::MaybeUninit<::RDKit::RingInfo>);
  ::new (ptr) ::std::shared_ptr<::RDKit::RingInfo>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$RingInfo$clone(::std::shared_ptr<::RDKit::RingInfo> const &self, ::std::shared_ptr<::RDKit::RingInfo> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::RingInfo>(self);
}
::RDKit::RingInfo const *cxxbridge1$shared_ptr$RDKit$RingInfo$get(::std::shared_ptr<::RDKit::RingInfo> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$RingInfo$drop(::std::shared_ptr<::RDKit::RingInfo> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::RingInfo>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::RingInfo>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$RingInfo$null(::std::weak_ptr<::RDKit::RingInfo> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RingInfo>();
}
void cxxbridge1$weak_ptr$RDKit$RingInfo$clone(::std::weak_ptr<::RDKit::RingInfo> const &self, ::std::weak_ptr<::RDKit::RingInfo> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::RingInfo>(self);
}
void cxxbridge1$weak_ptr$RDKit$RingInfo$downgrade(::std::shared_ptr<::RDKit::RingInfo> const &shared, ::std::weak_ptr<::RDKit::RingInfo> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::RingInfo>(shared);
}
void cxxbridge1$weak_ptr$RDKit$RingInfo$upgrade(::std::weak_ptr<::RDKit::RingInfo> const &weak, ::std::shared_ptr<::RDKit::RingInfo> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::RingInfo>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$RingInfo$drop(::std::weak_ptr<::RDKit::RingInfo> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::RingInfo> *cxxbridge1$std$vector$RDKit$RingInfo$new() noexcept {
  return new ::std::vector<::RDKit::RingInfo>();
}
::std::size_t cxxbridge1$std$vector$RDKit$RingInfo$size(::std::vector<::RDKit::RingInfo> const &s) noexcept {
  return s.size();
}
::RDKit::RingInfo *cxxbridge1$std$vector$RDKit$RingInfo$get_unchecked(::std::vector<::RDKit::RingInfo> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$RingInfo$push_back(::std::vector<::RDKit::RingInfo> *v, ::RDKit::RingInfo *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$RingInfo$pop_back(::std::vector<::RDKit::RingInfo> *v, ::RDKit::RingInfo *out) noexcept {
  ::new (out) ::RDKit::RingInfo(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::RingInfo>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::RingInfo>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$RingInfo$null(::std::unique_ptr<::std::vector<::RDKit::RingInfo>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::RingInfo>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$RingInfo$raw(::std::unique_ptr<::std::vector<::RDKit::RingInfo>> *ptr, ::std::vector<::RDKit::RingInfo> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::RingInfo>>(raw);
}
::std::vector<::RDKit::RingInfo> const *cxxbridge1$unique_ptr$std$vector$RDKit$RingInfo$get(::std::unique_ptr<::std::vector<::RDKit::RingInfo>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::RingInfo> *cxxbridge1$unique_ptr$std$vector$RDKit$RingInfo$release(::std::unique_ptr<::std::vector<::RDKit::RingInfo>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$RingInfo$drop(::std::unique_ptr<::std::vector<::RDKit::RingInfo>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDKit::ROMol>::value, "definition of ROMol is required");
static_assert(sizeof(::std::unique_ptr<::RDKit::ROMol>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDKit::ROMol>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDKit$ROMol$null(::std::unique_ptr<::RDKit::ROMol> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::ROMol>();
}
::RDKit::ROMol *cxxbridge1$unique_ptr$RDKit$ROMol$uninit(::std::unique_ptr<::RDKit::ROMol> *ptr) noexcept {
  ::RDKit::ROMol *uninit = reinterpret_cast<::RDKit::ROMol *>(new ::rust::MaybeUninit<::RDKit::ROMol>);
  ::new (ptr) ::std::unique_ptr<::RDKit::ROMol>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDKit$ROMol$raw(::std::unique_ptr<::RDKit::ROMol> *ptr, ::RDKit::ROMol *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDKit::ROMol>(raw);
}
::RDKit::ROMol const *cxxbridge1$unique_ptr$RDKit$ROMol$get(::std::unique_ptr<::RDKit::ROMol> const &ptr) noexcept {
  return ptr.get();
}
::RDKit::ROMol *cxxbridge1$unique_ptr$RDKit$ROMol$release(::std::unique_ptr<::RDKit::ROMol> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDKit$ROMol$drop(::std::unique_ptr<::RDKit::ROMol> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDKit::ROMol>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDKit::ROMol>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDKit::ROMol>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDKit$ROMol$null(::std::shared_ptr<::RDKit::ROMol> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::ROMol>();
}
::RDKit::ROMol *cxxbridge1$shared_ptr$RDKit$ROMol$uninit(::std::shared_ptr<::RDKit::ROMol> *ptr) noexcept {
  ::RDKit::ROMol *uninit = reinterpret_cast<::RDKit::ROMol *>(new ::rust::MaybeUninit<::RDKit::ROMol>);
  ::new (ptr) ::std::shared_ptr<::RDKit::ROMol>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDKit$ROMol$clone(::std::shared_ptr<::RDKit::ROMol> const &self, ::std::shared_ptr<::RDKit::ROMol> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDKit::ROMol>(self);
}
::RDKit::ROMol const *cxxbridge1$shared_ptr$RDKit$ROMol$get(::std::shared_ptr<::RDKit::ROMol> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDKit$ROMol$drop(::std::shared_ptr<::RDKit::ROMol> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDKit::ROMol>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDKit::ROMol>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDKit$ROMol$null(::std::weak_ptr<::RDKit::ROMol> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::ROMol>();
}
void cxxbridge1$weak_ptr$RDKit$ROMol$clone(::std::weak_ptr<::RDKit::ROMol> const &self, ::std::weak_ptr<::RDKit::ROMol> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDKit::ROMol>(self);
}
void cxxbridge1$weak_ptr$RDKit$ROMol$downgrade(::std::shared_ptr<::RDKit::ROMol> const &shared, ::std::weak_ptr<::RDKit::ROMol> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDKit::ROMol>(shared);
}
void cxxbridge1$weak_ptr$RDKit$ROMol$upgrade(::std::weak_ptr<::RDKit::ROMol> const &weak, ::std::shared_ptr<::RDKit::ROMol> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDKit::ROMol>(weak.lock());
}
void cxxbridge1$weak_ptr$RDKit$ROMol$drop(::std::weak_ptr<::RDKit::ROMol> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::RDKit::ROMol> *cxxbridge1$std$vector$RDKit$ROMol$new() noexcept {
  return new ::std::vector<::RDKit::ROMol>();
}
::std::size_t cxxbridge1$std$vector$RDKit$ROMol$size(::std::vector<::RDKit::ROMol> const &s) noexcept {
  return s.size();
}
::RDKit::ROMol *cxxbridge1$std$vector$RDKit$ROMol$get_unchecked(::std::vector<::RDKit::ROMol> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$RDKit$ROMol$push_back(::std::vector<::RDKit::ROMol> *v, ::RDKit::ROMol *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$RDKit$ROMol$pop_back(::std::vector<::RDKit::ROMol> *v, ::RDKit::ROMol *out) noexcept {
  ::new (out) ::RDKit::ROMol(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::RDKit::ROMol>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::RDKit::ROMol>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$RDKit$ROMol$null(::std::unique_ptr<::std::vector<::RDKit::ROMol>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::ROMol>>();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$ROMol$raw(::std::unique_ptr<::std::vector<::RDKit::ROMol>> *ptr, ::std::vector<::RDKit::ROMol> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::RDKit::ROMol>>(raw);
}
::std::vector<::RDKit::ROMol> const *cxxbridge1$unique_ptr$std$vector$RDKit$ROMol$get(::std::unique_ptr<::std::vector<::RDKit::ROMol>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::RDKit::ROMol> *cxxbridge1$unique_ptr$std$vector$RDKit$ROMol$release(::std::unique_ptr<::std::vector<::RDKit::ROMol>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$RDKit$ROMol$drop(::std::unique_ptr<::std::vector<::RDKit::ROMol>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::boost::any>::value, "definition of any is required");
static_assert(sizeof(::std::unique_ptr<::boost::any>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::boost::any>) == alignof(void *), "");
void cxxbridge1$unique_ptr$boost$any$null(::std::unique_ptr<::boost::any> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::boost::any>();
}
::boost::any *cxxbridge1$unique_ptr$boost$any$uninit(::std::unique_ptr<::boost::any> *ptr) noexcept {
  ::boost::any *uninit = reinterpret_cast<::boost::any *>(new ::rust::MaybeUninit<::boost::any>);
  ::new (ptr) ::std::unique_ptr<::boost::any>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$boost$any$raw(::std::unique_ptr<::boost::any> *ptr, ::boost::any *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::boost::any>(raw);
}
::boost::any const *cxxbridge1$unique_ptr$boost$any$get(::std::unique_ptr<::boost::any> const &ptr) noexcept {
  return ptr.get();
}
::boost::any *cxxbridge1$unique_ptr$boost$any$release(::std::unique_ptr<::boost::any> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$boost$any$drop(::std::unique_ptr<::boost::any> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::boost::any>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::boost::any>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::boost::any>) == alignof(void *), "");
void cxxbridge1$shared_ptr$boost$any$null(::std::shared_ptr<::boost::any> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::boost::any>();
}
::boost::any *cxxbridge1$shared_ptr$boost$any$uninit(::std::shared_ptr<::boost::any> *ptr) noexcept {
  ::boost::any *uninit = reinterpret_cast<::boost::any *>(new ::rust::MaybeUninit<::boost::any>);
  ::new (ptr) ::std::shared_ptr<::boost::any>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$boost$any$clone(::std::shared_ptr<::boost::any> const &self, ::std::shared_ptr<::boost::any> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::boost::any>(self);
}
::boost::any const *cxxbridge1$shared_ptr$boost$any$get(::std::shared_ptr<::boost::any> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$boost$any$drop(::std::shared_ptr<::boost::any> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::boost::any>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::boost::any>) == alignof(void *), "");
void cxxbridge1$weak_ptr$boost$any$null(::std::weak_ptr<::boost::any> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::boost::any>();
}
void cxxbridge1$weak_ptr$boost$any$clone(::std::weak_ptr<::boost::any> const &self, ::std::weak_ptr<::boost::any> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::boost::any>(self);
}
void cxxbridge1$weak_ptr$boost$any$downgrade(::std::shared_ptr<::boost::any> const &shared, ::std::weak_ptr<::boost::any> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::boost::any>(shared);
}
void cxxbridge1$weak_ptr$boost$any$upgrade(::std::weak_ptr<::boost::any> const &weak, ::std::shared_ptr<::boost::any> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::boost::any>(weak.lock());
}
void cxxbridge1$weak_ptr$boost$any$drop(::std::weak_ptr<::boost::any> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::boost::any> *cxxbridge1$std$vector$boost$any$new() noexcept {
  return new ::std::vector<::boost::any>();
}
::std::size_t cxxbridge1$std$vector$boost$any$size(::std::vector<::boost::any> const &s) noexcept {
  return s.size();
}
::boost::any *cxxbridge1$std$vector$boost$any$get_unchecked(::std::vector<::boost::any> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$boost$any$push_back(::std::vector<::boost::any> *v, ::boost::any *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$boost$any$pop_back(::std::vector<::boost::any> *v, ::boost::any *out) noexcept {
  ::new (out) ::boost::any(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::boost::any>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::boost::any>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$boost$any$null(::std::unique_ptr<::std::vector<::boost::any>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::boost::any>>();
}
void cxxbridge1$unique_ptr$std$vector$boost$any$raw(::std::unique_ptr<::std::vector<::boost::any>> *ptr, ::std::vector<::boost::any> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::boost::any>>(raw);
}
::std::vector<::boost::any> const *cxxbridge1$unique_ptr$std$vector$boost$any$get(::std::unique_ptr<::std::vector<::boost::any>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::boost::any> *cxxbridge1$unique_ptr$std$vector$boost$any$release(::std::unique_ptr<::std::vector<::boost::any>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$boost$any$drop(::std::unique_ptr<::std::vector<::boost::any>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::std_reverse_iterator_iterator_AutocxxConcrete>::value, "definition of std_reverse_iterator_iterator_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std_reverse_iterator_iterator_AutocxxConcrete$null(::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$std_reverse_iterator_iterator_AutocxxConcrete$raw(::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *ptr, ::std_reverse_iterator_iterator_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>(raw);
}
::std_reverse_iterator_iterator_AutocxxConcrete const *cxxbridge1$unique_ptr$std_reverse_iterator_iterator_AutocxxConcrete$get(::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::std_reverse_iterator_iterator_AutocxxConcrete *cxxbridge1$unique_ptr$std_reverse_iterator_iterator_AutocxxConcrete$release(::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std_reverse_iterator_iterator_AutocxxConcrete$drop(::std::unique_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::std_reverse_iterator_iterator_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$std_reverse_iterator_iterator_AutocxxConcrete$null(::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$std_reverse_iterator_iterator_AutocxxConcrete$clone(::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> const &self, ::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>(self);
}
::std_reverse_iterator_iterator_AutocxxConcrete const *cxxbridge1$shared_ptr$std_reverse_iterator_iterator_AutocxxConcrete$get(::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$std_reverse_iterator_iterator_AutocxxConcrete$drop(::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$std_reverse_iterator_iterator_AutocxxConcrete$null(::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$std_reverse_iterator_iterator_AutocxxConcrete$clone(::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> const &self, ::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$std_reverse_iterator_iterator_AutocxxConcrete$downgrade(::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> const &shared, ::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$std_reverse_iterator_iterator_AutocxxConcrete$upgrade(::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> const &weak, ::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::std_reverse_iterator_iterator_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$std_reverse_iterator_iterator_AutocxxConcrete$drop(::std::weak_ptr<::std_reverse_iterator_iterator_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::std_reverse_iterator_uint64_t_AutocxxConcrete>::value, "definition of std_reverse_iterator_uint64_t_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$null(::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$raw(::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *ptr, ::std_reverse_iterator_uint64_t_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>(raw);
}
::std_reverse_iterator_uint64_t_AutocxxConcrete const *cxxbridge1$unique_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$get(::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::std_reverse_iterator_uint64_t_AutocxxConcrete *cxxbridge1$unique_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$release(::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$drop(::std::unique_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::std_reverse_iterator_uint64_t_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$null(::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$clone(::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> const &self, ::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>(self);
}
::std_reverse_iterator_uint64_t_AutocxxConcrete const *cxxbridge1$shared_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$get(::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$drop(::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$null(::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$clone(::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> const &self, ::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$downgrade(::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> const &shared, ::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$upgrade(::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> const &weak, ::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$std_reverse_iterator_uint64_t_AutocxxConcrete$drop(::std::weak_ptr<::std_reverse_iterator_uint64_t_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::boost_uniform_real_double_AutocxxConcrete>::value, "definition of boost_uniform_real_double_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$boost_uniform_real_double_AutocxxConcrete$null(::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$boost_uniform_real_double_AutocxxConcrete$raw(::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete> *ptr, ::boost_uniform_real_double_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete>(raw);
}
::boost_uniform_real_double_AutocxxConcrete const *cxxbridge1$unique_ptr$boost_uniform_real_double_AutocxxConcrete$get(::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::boost_uniform_real_double_AutocxxConcrete *cxxbridge1$unique_ptr$boost_uniform_real_double_AutocxxConcrete$release(::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$boost_uniform_real_double_AutocxxConcrete$drop(::std::unique_ptr<::boost_uniform_real_double_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::boost_uniform_real_double_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$boost_uniform_real_double_AutocxxConcrete$null(::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$boost_uniform_real_double_AutocxxConcrete$clone(::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete> const &self, ::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete>(self);
}
::boost_uniform_real_double_AutocxxConcrete const *cxxbridge1$shared_ptr$boost_uniform_real_double_AutocxxConcrete$get(::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$boost_uniform_real_double_AutocxxConcrete$drop(::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$boost_uniform_real_double_AutocxxConcrete$null(::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$boost_uniform_real_double_AutocxxConcrete$clone(::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete> const &self, ::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$boost_uniform_real_double_AutocxxConcrete$downgrade(::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete> const &shared, ::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$boost_uniform_real_double_AutocxxConcrete$upgrade(::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete> const &weak, ::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::boost_uniform_real_double_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$boost_uniform_real_double_AutocxxConcrete$drop(::std::weak_ptr<::boost_uniform_real_double_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::boost_adjacency_list_boost_no_property_AutocxxConcrete>::value, "definition of boost_adjacency_list_boost_no_property_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$null(::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$raw(::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *ptr, ::boost_adjacency_list_boost_no_property_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>(raw);
}
::boost_adjacency_list_boost_no_property_AutocxxConcrete const *cxxbridge1$unique_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$get(::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::boost_adjacency_list_boost_no_property_AutocxxConcrete *cxxbridge1$unique_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$release(::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$drop(::std::unique_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::boost_adjacency_list_boost_no_property_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$null(::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$clone(::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> const &self, ::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>(self);
}
::boost_adjacency_list_boost_no_property_AutocxxConcrete const *cxxbridge1$shared_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$get(::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$drop(::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$null(::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$clone(::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> const &self, ::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$downgrade(::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> const &shared, ::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$upgrade(::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> const &weak, ::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$boost_adjacency_list_boost_no_property_AutocxxConcrete$drop(::std::weak_ptr<::boost_adjacency_list_boost_no_property_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>::value, "definition of std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$null(::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$raw(::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *ptr, ::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>(raw);
}
::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete const *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$get(::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$release(::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$drop(::std::unique_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$null(::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$clone(::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> const &self, ::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>(self);
}
::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete const *cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$get(::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$drop(::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$null(::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$clone(::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> const &self, ::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$downgrade(::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> const &shared, ::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$upgrade(::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> const &weak, ::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete$drop(::std::weak_ptr<::std_pair_RDKit_ROMol_EDGE_ITER_RDKit_ROMol_EDGE_ITER_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>::value, "definition of std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$null(::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$raw(::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *ptr, ::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>(raw);
}
::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete const *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$get(::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$release(::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$drop(::std::unique_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$null(::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$clone(::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> const &self, ::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>(self);
}
::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete const *cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$get(::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$drop(::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$null(::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$clone(::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> const &self, ::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$downgrade(::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> const &shared, ::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$upgrade(::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> const &weak, ::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete$drop(::std::weak_ptr<::std_pair_RDKit_ROMol_OEDGE_ITER_RDKit_ROMol_OEDGE_ITER_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>::value, "definition of std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$null(::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$raw(::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *ptr, ::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>(raw);
}
::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete const *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$get(::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$release(::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$drop(::std::unique_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$null(::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$clone(::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> const &self, ::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>(self);
}
::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete const *cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$get(::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$drop(::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$null(::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$clone(::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> const &self, ::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$downgrade(::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> const &shared, ::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$upgrade(::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> const &weak, ::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete$drop(::std::weak_ptr<::std_pair_RDKit_ROMol_VERTEX_ITER_RDKit_ROMol_VERTEX_ITER_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>::value, "definition of std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$null(::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$raw(::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *ptr, ::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>(raw);
}
::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete const *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$get(::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$release(::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$drop(::std::unique_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$null(::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$clone(::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> const &self, ::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>(self);
}
::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete const *cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$get(::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$drop(::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$null(::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$clone(::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> const &self, ::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$downgrade(::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> const &shared, ::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$upgrade(::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> const &weak, ::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete$drop(::std::weak_ptr<::std_pair_RDKit_ROMol_ADJ_ITER_RDKit_ROMol_ADJ_ITER_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>::value, "definition of std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete is required");
static_assert(sizeof(::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$null(::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$raw(::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *ptr, ::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>(raw);
}
::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete const *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$get(::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> const &ptr) noexcept {
  return ptr.get();
}
::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete *cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$release(::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$drop(::std::unique_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$null(::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$clone(::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> const &self, ::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>(self);
}
::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete const *cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$get(::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$drop(::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>) == alignof(void *), "");
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$null(::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>();
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$clone(::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> const &self, ::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>(self);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$downgrade(::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> const &shared, ::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>(shared);
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$upgrade(::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> const &weak, ::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete>(weak.lock());
}
void cxxbridge1$weak_ptr$std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete$drop(::std::weak_ptr<::std_pair_RDKit_ROMol_CONF_SPTR_LIST_I_RDKit_ROMol_CONF_SPTR_LIST_I_AutocxxConcrete> *self) noexcept {
  self->~weak_ptr();
}

static_assert(::rust::detail::is_complete<::Queries::CompositeQueryType>::value, "definition of CompositeQueryType is required");
static_assert(sizeof(::std::unique_ptr<::Queries::CompositeQueryType>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::Queries::CompositeQueryType>) == alignof(void *), "");
void cxxbridge1$unique_ptr$Queries$CompositeQueryType$null(::std::unique_ptr<::Queries::CompositeQueryType> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::Queries::CompositeQueryType>();
}
::Queries::CompositeQueryType *cxxbridge1$unique_ptr$Queries$CompositeQueryType$uninit(::std::unique_ptr<::Queries::CompositeQueryType> *ptr) noexcept {
  ::Queries::CompositeQueryType *uninit = reinterpret_cast<::Queries::CompositeQueryType *>(new ::rust::MaybeUninit<::Queries::CompositeQueryType>);
  ::new (ptr) ::std::unique_ptr<::Queries::CompositeQueryType>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$Queries$CompositeQueryType$raw(::std::unique_ptr<::Queries::CompositeQueryType> *ptr, ::Queries::CompositeQueryType *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::Queries::CompositeQueryType>(raw);
}
::Queries::CompositeQueryType const *cxxbridge1$unique_ptr$Queries$CompositeQueryType$get(::std::unique_ptr<::Queries::CompositeQueryType> const &ptr) noexcept {
  return ptr.get();
}
::Queries::CompositeQueryType *cxxbridge1$unique_ptr$Queries$CompositeQueryType$release(::std::unique_ptr<::Queries::CompositeQueryType> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$Queries$CompositeQueryType$drop(::std::unique_ptr<::Queries::CompositeQueryType> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::Queries::CompositeQueryType>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::Queries::CompositeQueryType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::Queries::CompositeQueryType>) == alignof(void *), "");
void cxxbridge1$shared_ptr$Queries$CompositeQueryType$null(::std::shared_ptr<::Queries::CompositeQueryType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::Queries::CompositeQueryType>();
}
::Queries::CompositeQueryType *cxxbridge1$shared_ptr$Queries$CompositeQueryType$uninit(::std::shared_ptr<::Queries::CompositeQueryType> *ptr) noexcept {
  ::Queries::CompositeQueryType *uninit = reinterpret_cast<::Queries::CompositeQueryType *>(new ::rust::MaybeUninit<::Queries::CompositeQueryType>);
  ::new (ptr) ::std::shared_ptr<::Queries::CompositeQueryType>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$Queries$CompositeQueryType$clone(::std::shared_ptr<::Queries::CompositeQueryType> const &self, ::std::shared_ptr<::Queries::CompositeQueryType> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::Queries::CompositeQueryType>(self);
}
::Queries::CompositeQueryType const *cxxbridge1$shared_ptr$Queries$CompositeQueryType$get(::std::shared_ptr<::Queries::CompositeQueryType> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$Queries$CompositeQueryType$drop(::std::shared_ptr<::Queries::CompositeQueryType> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::Queries::CompositeQueryType>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::Queries::CompositeQueryType>) == alignof(void *), "");
void cxxbridge1$weak_ptr$Queries$CompositeQueryType$null(::std::weak_ptr<::Queries::CompositeQueryType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::Queries::CompositeQueryType>();
}
void cxxbridge1$weak_ptr$Queries$CompositeQueryType$clone(::std::weak_ptr<::Queries::CompositeQueryType> const &self, ::std::weak_ptr<::Queries::CompositeQueryType> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::Queries::CompositeQueryType>(self);
}
void cxxbridge1$weak_ptr$Queries$CompositeQueryType$downgrade(::std::shared_ptr<::Queries::CompositeQueryType> const &shared, ::std::weak_ptr<::Queries::CompositeQueryType> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::Queries::CompositeQueryType>(shared);
}
void cxxbridge1$weak_ptr$Queries$CompositeQueryType$upgrade(::std::weak_ptr<::Queries::CompositeQueryType> const &weak, ::std::shared_ptr<::Queries::CompositeQueryType> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::Queries::CompositeQueryType>(weak.lock());
}
void cxxbridge1$weak_ptr$Queries$CompositeQueryType$drop(::std::weak_ptr<::Queries::CompositeQueryType> *self) noexcept {
  self->~weak_ptr();
}

::std::vector<::Queries::CompositeQueryType> *cxxbridge1$std$vector$Queries$CompositeQueryType$new() noexcept {
  return new ::std::vector<::Queries::CompositeQueryType>();
}
::std::size_t cxxbridge1$std$vector$Queries$CompositeQueryType$size(::std::vector<::Queries::CompositeQueryType> const &s) noexcept {
  return s.size();
}
::Queries::CompositeQueryType *cxxbridge1$std$vector$Queries$CompositeQueryType$get_unchecked(::std::vector<::Queries::CompositeQueryType> *s, ::std::size_t pos) noexcept {
  return &(*s)[pos];
}
void cxxbridge1$std$vector$Queries$CompositeQueryType$push_back(::std::vector<::Queries::CompositeQueryType> *v, ::Queries::CompositeQueryType *value) noexcept {
  v->push_back(::std::move(*value));
  ::rust::destroy(value);
}
void cxxbridge1$std$vector$Queries$CompositeQueryType$pop_back(::std::vector<::Queries::CompositeQueryType> *v, ::Queries::CompositeQueryType *out) noexcept {
  ::new (out) ::Queries::CompositeQueryType(::std::move(v->back()));
  v->pop_back();
}
static_assert(sizeof(::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>>) == alignof(void *), "");
void cxxbridge1$unique_ptr$std$vector$Queries$CompositeQueryType$null(::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>>();
}
void cxxbridge1$unique_ptr$std$vector$Queries$CompositeQueryType$raw(::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>> *ptr, ::std::vector<::Queries::CompositeQueryType> *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>>(raw);
}
::std::vector<::Queries::CompositeQueryType> const *cxxbridge1$unique_ptr$std$vector$Queries$CompositeQueryType$get(::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>> const &ptr) noexcept {
  return ptr.get();
}
::std::vector<::Queries::CompositeQueryType> *cxxbridge1$unique_ptr$std$vector$Queries$CompositeQueryType$release(::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$std$vector$Queries$CompositeQueryType$drop(::std::unique_ptr<::std::vector<::Queries::CompositeQueryType>> *ptr) noexcept {
  ptr->~unique_ptr();
}

static_assert(::rust::detail::is_complete<::RDGeom::Point3D>::value, "definition of Point3D is required");
static_assert(sizeof(::std::unique_ptr<::RDGeom::Point3D>) == sizeof(void *), "");
static_assert(alignof(::std::unique_ptr<::RDGeom::Point3D>) == alignof(void *), "");
void cxxbridge1$unique_ptr$RDGeom$Point3D$null(::std::unique_ptr<::RDGeom::Point3D> *ptr) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDGeom::Point3D>();
}
::RDGeom::Point3D *cxxbridge1$unique_ptr$RDGeom$Point3D$uninit(::std::unique_ptr<::RDGeom::Point3D> *ptr) noexcept {
  ::RDGeom::Point3D *uninit = reinterpret_cast<::RDGeom::Point3D *>(new ::rust::MaybeUninit<::RDGeom::Point3D>);
  ::new (ptr) ::std::unique_ptr<::RDGeom::Point3D>(uninit);
  return uninit;
}
void cxxbridge1$unique_ptr$RDGeom$Point3D$raw(::std::unique_ptr<::RDGeom::Point3D> *ptr, ::RDGeom::Point3D *raw) noexcept {
  ::new (ptr) ::std::unique_ptr<::RDGeom::Point3D>(raw);
}
::RDGeom::Point3D const *cxxbridge1$unique_ptr$RDGeom$Point3D$get(::std::unique_ptr<::RDGeom::Point3D> const &ptr) noexcept {
  return ptr.get();
}
::RDGeom::Point3D *cxxbridge1$unique_ptr$RDGeom$Point3D$release(::std::unique_ptr<::RDGeom::Point3D> &ptr) noexcept {
  return ptr.release();
}
void cxxbridge1$unique_ptr$RDGeom$Point3D$drop(::std::unique_ptr<::RDGeom::Point3D> *ptr) noexcept {
  ::rust::deleter_if<::rust::detail::is_complete<::RDGeom::Point3D>::value>{}(ptr);
}

static_assert(sizeof(::std::shared_ptr<::RDGeom::Point3D>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::shared_ptr<::RDGeom::Point3D>) == alignof(void *), "");
void cxxbridge1$shared_ptr$RDGeom$Point3D$null(::std::shared_ptr<::RDGeom::Point3D> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDGeom::Point3D>();
}
::RDGeom::Point3D *cxxbridge1$shared_ptr$RDGeom$Point3D$uninit(::std::shared_ptr<::RDGeom::Point3D> *ptr) noexcept {
  ::RDGeom::Point3D *uninit = reinterpret_cast<::RDGeom::Point3D *>(new ::rust::MaybeUninit<::RDGeom::Point3D>);
  ::new (ptr) ::std::shared_ptr<::RDGeom::Point3D>(uninit);
  return uninit;
}
void cxxbridge1$shared_ptr$RDGeom$Point3D$clone(::std::shared_ptr<::RDGeom::Point3D> const &self, ::std::shared_ptr<::RDGeom::Point3D> *ptr) noexcept {
  ::new (ptr) ::std::shared_ptr<::RDGeom::Point3D>(self);
}
::RDGeom::Point3D const *cxxbridge1$shared_ptr$RDGeom$Point3D$get(::std::shared_ptr<::RDGeom::Point3D> const &self) noexcept {
  return self.get();
}
void cxxbridge1$shared_ptr$RDGeom$Point3D$drop(::std::shared_ptr<::RDGeom::Point3D> *self) noexcept {
  self->~shared_ptr();
}

static_assert(sizeof(::std::weak_ptr<::RDGeom::Point3D>) == 2 * sizeof(void *), "");
static_assert(alignof(::std::weak_ptr<::RDGeom::Point3D>) == alignof(void *), "");
void cxxbridge1$weak_ptr$RDGeom$Point3D$null(::std::weak_ptr<::RDGeom::Point3D> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDGeom::Point3D>();
}
void cxxbridge1$weak_ptr$RDGeom$Point3D$clone(::std::weak_ptr<::RDGeom::Point3D> const &self, ::std::weak_ptr<::RDGeom::Point3D> *ptr) noexcept {
  ::new (ptr) ::std::weak_ptr<::RDGeom::Point3D>(self);
}
void cxxbridge1$weak_ptr$RDGeom$Point3D$downgrade(::std::shared_ptr<::RDGeom::Point3D> const &shared, ::std::weak_ptr<::RDGeom::Point3D> *weak) noexcept {
  ::new (weak) ::std::weak_ptr<::RDGeom::Point3D>(shared);
}
void cxxbridge1$weak_ptr$RDGeom$Point3D$upgrade(::std::weak_ptr<::RDGeom::Point3D> const &weak, ::std::shared_ptr<::RDGeom::Point3D> *shared) noexcept {
  ::new (shared) ::std::shared_ptr<::RDGeom::Point3D>(weak.lock());
}
void cxxbridge1$weak_ptr$RDGeom$Point3D$drop(::std::weak_ptr<::RDGeom::Point3D> *self) noexcept {
  self->~weak_ptr();
}
} // extern "C"

## ROMol.h
// FROM /opt/homebrew/include/rdkit/GraphMol/ROMol.h
//
//  Copyright (C) 2003-2022 Greg Landrum and other RDKit contributors
//
//   @@ All Rights Reserved @@
//  This file is part of the RDKit.
//  The contents are covered by the terms of the BSD license
//  which is included in the file license.txt, found at the root
//  of the RDKit source tree.
//
/*! \file ROMol.h

  \brief Defines the primary molecule class \c ROMol as well as associated
  typedefs

*/

#include <RDGeneral/export.h>
#ifndef RD_ROMOL_H
#define RD_ROMOL_H

/// Std stuff
#include <cstddef>
#include <iterator>
#include <utility>
#include <map>

// boost stuff
#include <RDGeneral/BoostStartInclude.h>
#include <boost/graph/adjacency_list.hpp>
#include <boost/smart_ptr.hpp>
#include <boost/dynamic_bitset.hpp>

#ifdef RDK_USE_BOOST_SERIALIZATION
#include <boost/serialization/split_member.hpp>
#endif
#include <RDGeneral/BoostEndInclude.h>

// our stuff
#include <RDGeneral/types.h>
#include <RDGeneral/RDProps.h>
#include "Atom.h"
#include "Bond.h"
#include "Conformer.h"
#include "SubstanceGroup.h"
#include "StereoGroup.h"
#include "RingInfo.h"

namespace RDKit {
class SubstanceGroup;
class Atom;
class Bond;
//! This is the BGL type used to store the topology:
typedef boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS,
                              Atom *, Bond *>
    MolGraph;
class MolPickler;
class RWMol;
class QueryAtom;
class QueryBond;
class RingInfo;

template <class T1, class T2>
class AtomIterator_;
class BondIterator_;
class ConstBondIterator_;

template <class T1, class T2>
class AromaticAtomIterator_;
template <class T1, class T2>
class HeteroatomIterator_;
template <class T1, class T2>
class QueryAtomIterator_;
template <class T1, class T2>
class MatchingAtomIterator_;

RDKIT_GRAPHMOL_EXPORT extern const int ci_RIGHTMOST_ATOM;
RDKIT_GRAPHMOL_EXPORT extern const int ci_LEADING_BOND;
RDKIT_GRAPHMOL_EXPORT extern const int ci_ATOM_HOLDER;

//! ROMol is a molecule class that is intended to have a fixed topology
/*!
  This is the primary class for most molecule operations.

  If you need to be manipulating the molecule (e.g. adding or deleting
  atoms or bonds, use an RWMol instead.

  <b>Notes:</b>
    - each ROMol maintains a Dict of \c properties:
        - Each \c property is keyed by name and can store an
          arbitrary type.
        - \c Properties can be marked as \c calculated, in which case
          they will be cleared when the \c clearComputedProps() method
          is called.
        - Because they have no impact upon chemistry, all \c property
          operations are \c const, this allows extra flexibility for
          clients who need to store extra data on ROMol objects.

    - each ROMol has collections of \c bookmarks for Atoms and Bonds:
        - the Atom bookmarks and Bond bookmarks are stored separately
          from each other
        - each \c bookmark, an integer, can map to more than one
          Atom or Bond
        - these are currently used in molecule construction, but
          could also be useful for reaction mapping and the like

    - information about rings (SSSR and the like) is stored in the
      molecule's RingInfo pointer.

 */

//! \name C++11 Iterators

template <class Graph, class Vertex,
          class Iterator = typename Graph::vertex_iterator>
struct CXXAtomIterator {
  Graph *graph;
  Iterator vstart, vend;

  struct CXXAtomIter {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = Vertex;
    using pointer = Vertex *;
    using reference = Vertex &;

    Graph *graph;
    Iterator pos;
    Atom *current;

    CXXAtomIter(Graph *graph, Iterator pos)
        : graph(graph), pos(pos), current(nullptr) {}

    reference operator*() {
      current = (*graph)[*pos];
      return current;
    }
    CXXAtomIter &operator++() {
      ++pos;
      return *this;
    }
    bool operator==(const CXXAtomIter &it) const { return pos == it.pos; }
    bool operator!=(const CXXAtomIter &it) const { return pos != it.pos; }
  };

  CXXAtomIterator(Graph *graph) : graph(graph) {
    auto vs = boost::vertices(*graph);
    vstart = vs.first;
    vend = vs.second;
  }
  CXXAtomIterator(Graph *graph, Iterator start, Iterator end)
      : graph(graph), vstart(start), vend(end){};
  CXXAtomIter begin() { return {graph, vstart}; }
  CXXAtomIter end() { return {graph, vend}; }
};

template <class Graph, class Edge,
          class Iterator = typename Graph::edge_iterator>
struct CXXBondIterator {
  Graph *graph;
  Iterator vstart, vend;

  struct CXXBondIter {
    using iterator_category = std::forward_iterator_tag;
    using difference_type = std::ptrdiff_t;
    using value_type = Edge;
    using pointer = Edge *;
    using reference = Edge &;

    Graph *graph;
    Iterator pos;
    Bond *current;

    CXXBondIter(Graph *graph, Iterator pos)
        : graph(graph), pos(pos), current(nullptr) {}

    reference operator*() {
      current = (*graph)[*pos];
      return current;
    }
    CXXBondIter &operator++() {
      ++pos;
      return *this;
    }
    bool operator==(const CXXBondIter &it) const { return pos == it.pos; }
    bool operator!=(const CXXBondIter &it) const { return pos != it.pos; }
  };

  CXXBondIterator(Graph *graph) : graph(graph) {
    auto vs = boost::edges(*graph);
    vstart = vs.first;
    vend = vs.second;
  }
  CXXBondIterator(Graph *graph, Iterator start, Iterator end)
      : graph(graph), vstart(start), vend(end){};
  CXXBondIter begin() { return {graph, vstart}; }
  CXXBondIter end() { return {graph, vend}; }
};

class RDKIT_GRAPHMOL_EXPORT ROMol : public RDProps {
 public:
  friend class MolPickler;
  friend class RWMol;

  //! \cond TYPEDEFS

  //! \name typedefs
  //! @{
  typedef MolGraph::vertex_descriptor vertex_descriptor;
  typedef MolGraph::edge_descriptor edge_descriptor;

  typedef MolGraph::edge_iterator EDGE_ITER;
  typedef MolGraph::out_edge_iterator OEDGE_ITER;
  typedef MolGraph::vertex_iterator VERTEX_ITER;
  typedef MolGraph::adjacency_iterator ADJ_ITER;
  typedef std::pair<EDGE_ITER, EDGE_ITER> BOND_ITER_PAIR;
  typedef std::pair<OEDGE_ITER, OEDGE_ITER> OBOND_ITER_PAIR;
  typedef std::pair<VERTEX_ITER, VERTEX_ITER> ATOM_ITER_PAIR;
  typedef std::pair<ADJ_ITER, ADJ_ITER> ADJ_ITER_PAIR;

  typedef std::vector<Atom *> ATOM_PTR_VECT;
  typedef ATOM_PTR_VECT::iterator ATOM_PTR_VECT_I;
  typedef ATOM_PTR_VECT::const_iterator ATOM_PTR_VECT_CI;
  typedef std::vector<Bond *> BOND_PTR_VECT;
  typedef BOND_PTR_VECT::iterator BOND_PTR_VECT_I;
  typedef BOND_PTR_VECT::const_iterator BOND_PTR_VECT_CI;

  typedef std::list<Atom *> ATOM_PTR_LIST;
  typedef ATOM_PTR_LIST::iterator ATOM_PTR_LIST_I;
  typedef ATOM_PTR_LIST::const_iterator ATOM_PTR_LIST_CI;
  typedef std::list<Bond *> BOND_PTR_LIST;
  typedef BOND_PTR_LIST::iterator BOND_PTR_LIST_I;
  typedef BOND_PTR_LIST::const_iterator BOND_PTR_LIST_CI;

  // list of conformations
  typedef std::list<CONFORMER_SPTR> CONF_SPTR_LIST;
  typedef CONF_SPTR_LIST::iterator CONF_SPTR_LIST_I;
  typedef CONF_SPTR_LIST::const_iterator CONF_SPTR_LIST_CI;
  typedef std::pair<CONF_SPTR_LIST_I, CONF_SPTR_LIST_I> CONFS_I_PAIR;

  // ROFIX: these will need to be readonly somehow?
  typedef std::map<int, ATOM_PTR_LIST> ATOM_BOOKMARK_MAP;
  typedef std::map<int, BOND_PTR_LIST> BOND_BOOKMARK_MAP;

  typedef class AtomIterator_<Atom, ROMol> AtomIterator;
  typedef class AtomIterator_<const Atom, const ROMol> ConstAtomIterator;
  typedef class BondIterator_ BondIterator;
  typedef class ConstBondIterator_ ConstBondIterator;
  typedef class AromaticAtomIterator_<Atom, ROMol> AromaticAtomIterator;
  typedef class AromaticAtomIterator_<const Atom, const ROMol>
      ConstAromaticAtomIterator;
  typedef class HeteroatomIterator_<Atom, ROMol> HeteroatomIterator;
  typedef class HeteroatomIterator_<const Atom, const ROMol>
      ConstHeteroatomIterator;
  typedef class QueryAtomIterator_<Atom, ROMol> QueryAtomIterator;
  typedef class QueryAtomIterator_<const Atom, const ROMol>
      ConstQueryAtomIterator;
  typedef class MatchingAtomIterator_<Atom, ROMol> MatchingAtomIterator;
  typedef class MatchingAtomIterator_<const Atom, const ROMol>
      ConstMatchingAtomIterator;

  typedef CONF_SPTR_LIST_I ConformerIterator;
  typedef CONF_SPTR_LIST_CI ConstConformerIterator;

  //! @}
  //! \endcond

  //! C++11 Range iterator
  /*!
    <b>Usage</b>
    \code
      for(auto atom : mol.atoms()) {
         atom->getIdx();
      };
    \endcode
   */

  CXXAtomIterator<MolGraph, Atom *> atoms() { return {&d_graph}; }

  CXXAtomIterator<const MolGraph, Atom *const> atoms() const {
    return {&d_graph};
  }

  CXXAtomIterator<const MolGraph, Atom *const, MolGraph::adjacency_iterator>
  atomNeighbors(Atom const *at) const {
    auto pr = getAtomNeighbors(at);
    return {&d_graph, pr.first, pr.second};
  }

  CXXAtomIterator<MolGraph, Atom *, MolGraph::adjacency_iterator> atomNeighbors(
      Atom const *at) {
    auto pr = getAtomNeighbors(at);
    return {&d_graph, pr.first, pr.second};
  }

  CXXBondIterator<const MolGraph, Bond *const, MolGraph::out_edge_iterator>
  atomBonds(Atom const *at) const {
    auto pr = getAtomBonds(at);
    return {&d_graph, pr.first, pr.second};
  }

  CXXBondIterator<MolGraph, Bond *, MolGraph::out_edge_iterator> atomBonds(
      Atom const *at) {
    auto pr = getAtomBonds(at);
    return {&d_graph, pr.first, pr.second};
  }

  /*!
  <b>Usage</b>
  \code
    for(auto bond : mol.bonds()) {
       bond->getIdx();
    };
  \endcode
 */

  CXXBondIterator<MolGraph, Bond *> bonds() { return {&d_graph}; }

  CXXBondIterator<const MolGraph, Bond *const> bonds() const {
    return {&d_graph};
  }

  ROMol() : RDProps() { initMol(); }

  //! copy constructor with a twist
  /*!
    \param other     the molecule to be copied
    \param quickCopy (optional) if this is true, the resulting ROMol will not
         copy any of the properties or bookmarks and conformers from \c other.
    This can
         make the copy substantially faster (thus the name).
    \param confId (optional) if this is >=0, the resulting ROMol will contain
    only
         the specified conformer from \c other.
  */
  ROMol(const ROMol &other, bool quickCopy = false, int confId = -1)
      : RDProps() {
    dp_ringInfo = nullptr;
    initFromOther(other, quickCopy, confId);
    numBonds = rdcast<unsigned int>(boost::num_edges(d_graph));
  }
  //! construct a molecule from a pickle string
  ROMol(const std::string &binStr);
  //! construct a molecule from a pickle string
  ROMol(const std::string &binStr, unsigned int propertyFlags);

  ROMol(ROMol &&o) noexcept
      : RDProps(std::move(o)),
        d_graph(std::move(o.d_graph)),
        d_atomBookmarks(std::move(o.d_atomBookmarks)),
        d_bondBookmarks(std::move(o.d_bondBookmarks)),
        d_confs(std::move(o.d_confs)),
        d_sgroups(std::move(o.d_sgroups)),
        d_stereo_groups(std::move(o.d_stereo_groups)),
        numBonds(o.numBonds) {
    for (auto atom : atoms()) {
      atom->setOwningMol(this);
    }
    for (auto bond : bonds()) {
      bond->setOwningMol(this);
    }
    for (auto conf : d_confs) {
      conf->setOwningMol(this);
    }
    o.d_graph.clear();
    o.numBonds = 0;
    dp_ringInfo = std::exchange(o.dp_ringInfo, nullptr);
    dp_delAtoms = std::exchange(o.dp_delAtoms, nullptr);
    dp_delBonds = std::exchange(o.dp_delBonds, nullptr);
  }
  ROMol &operator=(ROMol &&o) noexcept {
    if (this == &o) {
      return *this;
    }
    RDProps::operator=(std::move(o));
    d_graph = std::move(o.d_graph);
    d_atomBookmarks = std::move(o.d_atomBookmarks);
    d_bondBookmarks = std::move(o.d_bondBookmarks);
    if (dp_ringInfo) {
      delete dp_ringInfo;
    }
    dp_ringInfo = std::exchange(o.dp_ringInfo, nullptr);

    d_confs = std::move(o.d_confs);
    d_sgroups = std::move(o.d_sgroups);
    d_stereo_groups = std::move(o.d_stereo_groups);
    dp_delAtoms = std::exchange(o.dp_delAtoms, nullptr);
    dp_delBonds = std::exchange(o.dp_delBonds, nullptr);
    numBonds = o.numBonds;
    o.numBonds = 0;

    for (auto atom : atoms()) {
      atom->setOwningMol(this);
    }
    for (auto bond : bonds()) {
      bond->setOwningMol(this);
    }
    for (auto conf : d_confs) {
      conf->setOwningMol(this);
    }

    o.d_graph.clear();
    return *this;
  }

  ROMol &operator=(const ROMol &) =
      delete;  // disable assignment, RWMol's support assignment

  virtual ~ROMol() { destroy(); }

  //! @}
  //! \name Atoms
  //! @{

  //! returns our number of atoms
  inline unsigned int getNumAtoms() const {
    return rdcast<unsigned int>(boost::num_vertices(d_graph));
  }
  unsigned int getNumAtoms(bool onlyExplicit) const;
  //! returns our number of heavy atoms (atomic number > 1)
  unsigned int getNumHeavyAtoms() const;
  //! returns a pointer to a particular Atom
  Atom *getAtomWithIdx(unsigned int idx);
  //! \overload
  const Atom *getAtomWithIdx(unsigned int idx) const;
  //! \overload
  template <class U>
  Atom *getAtomWithIdx(const U idx) {
    return getAtomWithIdx(rdcast<unsigned int>(idx));
  }
  //! \overload
  template <class U>
  const Atom *getAtomWithIdx(const U idx) const {
    return getAtomWithIdx(rdcast<unsigned int>(idx));
  }
  //! returns the degree (number of neighbors) of an Atom in the graph
  unsigned int getAtomDegree(const Atom *at) const;
  //! @}

  //! \name Bonds
  //! @{

  //! returns our number of Bonds
  unsigned int getNumBonds(bool onlyHeavy = 1) const;
  //! returns a pointer to a particular Bond
  Bond *getBondWithIdx(unsigned int idx);
  //! \overload
  const Bond *getBondWithIdx(unsigned int idx) const;
  //! \overload
  template <class U>
  Bond *getBondWithIdx(const U idx) {
    return getBondWithIdx(rdcast<unsigned int>(idx));
  }
  //! \overload
  template <class U>
  const Bond *getBondWithIdx(const U idx) const {
    return getBondWithIdx(rdcast<unsigned int>(idx));
  }
  //! returns a pointer to the bond between two atoms, Null on failure
  Bond *getBondBetweenAtoms(unsigned int idx1, unsigned int idx2);
  //! \overload
  const Bond *getBondBetweenAtoms(unsigned int idx1, unsigned int idx2) const;
  //! \overload
  template <class U, class V>
  Bond *getBondBetweenAtoms(const U idx1, const V idx2) {
    return getBondBetweenAtoms(rdcast<unsigned int>(idx1),
                               rdcast<unsigned int>(idx2));
  }
  //! \overload
  template <class U, class V>
  const Bond *getBondBetweenAtoms(const U idx1, const V idx2) const {
    return getBondBetweenAtoms(rdcast<unsigned int>(idx1),
                               rdcast<unsigned int>(idx2));
  }

  //! @}

  //! \name Bookmarks
  //! @{

  //! associates an Atom pointer with a bookmark
  void setAtomBookmark(Atom *at, int mark) {
    d_atomBookmarks[mark].push_back(at);
  }
  //! associates an Atom pointer with a bookmark
  void replaceAtomBookmark(Atom *at, int mark) {
    d_atomBookmarks[mark].clear();
    d_atomBookmarks[mark].push_back(at);
  }
  //! returns the first Atom associated with the \c bookmark provided
  Atom *getAtomWithBookmark(int mark);
  //! returns the Atom associated with the \c bookmark provided
  //! a check is made to ensure it is the only atom with that bookmark
  Atom *getUniqueAtomWithBookmark(int mark);
  //! returns all Atoms associated with the \c bookmark provided
  ATOM_PTR_LIST &getAllAtomsWithBookmark(int mark);
  //! removes a \c bookmark from our collection
  void clearAtomBookmark(int mark);
  //! removes a particular Atom from the list associated with the \c bookmark
  void clearAtomBookmark(int mark, const Atom *atom);

  //! blows out all atomic \c bookmarks
  void clearAllAtomBookmarks() { d_atomBookmarks.clear(); }
  //! queries whether or not any atoms are associated with a \c bookmark
  bool hasAtomBookmark(int mark) const { return d_atomBookmarks.count(mark); }
  //! returns a pointer to all of our atom \c bookmarks
  ATOM_BOOKMARK_MAP *getAtomBookmarks() { return &d_atomBookmarks; }

  //! associates a Bond pointer with a bookmark
  void setBondBookmark(Bond *bond, int mark) {
    d_bondBookmarks[mark].push_back(bond);
  }
  //! returns the first Bond associated with the \c bookmark provided
  Bond *getBondWithBookmark(int mark);
  //! returns the Bond associated with the \c bookmark provided
  //! a check is made to ensure it is the only bond with that bookmark
  Bond *getUniqueBondWithBookmark(int mark);
  //! returns all bonds associated with the \c bookmark provided
  BOND_PTR_LIST &getAllBondsWithBookmark(int mark);
  //! removes a \c bookmark from our collection
  void clearBondBookmark(int mark);
  //! removes a particular Bond from the list associated with the \c bookmark
  void clearBondBookmark(int mark, const Bond *bond);

  //! blows out all bond \c bookmarks
  void clearAllBondBookmarks() { d_bondBookmarks.clear(); }
  //! queries whether or not any bonds are associated with a \c bookmark
  bool hasBondBookmark(int mark) const { return d_bondBookmarks.count(mark); }
  //! returns a pointer to all of our bond \c bookmarks
  BOND_BOOKMARK_MAP *getBondBookmarks() { return &d_bondBookmarks; }

  //! @}

  //! \name Conformers
  //! @{

  //! return the conformer with a specified ID
  //! if the ID is negative the first conformation will be returned
  const Conformer &getConformer(int id = -1) const;

  //! return the conformer with a specified ID
  //! if the ID is negative the first conformation will be returned
  Conformer &getConformer(int id = -1);

  //! Delete the conformation with the specified ID
  void removeConformer(unsigned int id);

  //! Clear all the conformations on the molecule
  void clearConformers() { d_confs.clear(); }

  //! Add a new conformation to the molecule
  /*!
    \param conf - conformation to be added to the molecule, this molecule takes
    ownership
                  of the conformer
    \param assignId - a unique ID will be assigned to the conformation if
    true
                      otherwise it is assumed that the conformation already has
    an (unique) ID set
  */
  unsigned int addConformer(Conformer *conf, bool assignId = false);

  inline unsigned int getNumConformers() const {
    return rdcast<unsigned int>(d_confs.size());
  }

  //! \name Topology
  //! @{

  //! returns a pointer to our RingInfo structure
  //! <b>Note:</b> the client should not delete this.
  RingInfo *getRingInfo() const { return dp_ringInfo; }

  //! provides access to all neighbors around an Atom
  /*!
    \param at the atom whose neighbors we are looking for

    <b>Usage</b>
    \code
      ... mol is a const ROMol & ...
      ... atomPtr is a const Atom * ...
      ... requires #include <boost/range/iterator_range.hpp>
      for (const auto &nbri :
           boost::make_iterator_range(m.getAtomNeighbors(atomPtr))) {
        const auto &nbr = (*m)[nbri];
        // nbr is an atom pointer
      }

    \endcode

  */
  ADJ_ITER_PAIR getAtomNeighbors(Atom const *at) const;

  //! provides access to all Bond objects connected to an Atom
  /*!
    \param at the atom whose neighbors we are looking for

    <b>Usage</b>
    \code
      ... mol is a const ROMol & ...
      ... atomPtr is a const Atom * ...
      ... requires #include <boost/range/iterator_range.hpp>
      for (const auto &nbri :
           boost::make_iterator_range(m.getAtomBonds(atomPtr))) {
        const auto &nbr = (*m)[nbri];
        // nbr is a bond pointer
      }
    \endcode
    or, if you need a non-const Bond *:
    \code
      ... mol is a const ROMol & ...
      ... atomPtr is a const Atom * ...
      ... requires #include <boost/range/iterator_range.hpp>
      for (const auto &nbri :
           boost::make_iterator_range(m.getAtomBonds(atomPtr))) {
        auto nbr = (*m)[nbri];
        // nbr is a bond pointer
      }
    \endcode


  */
  OBOND_ITER_PAIR getAtomBonds(Atom const *at) const;

  //! returns an iterator pair for looping over all Atoms
  /*!

    <b>Usage</b>
    \code

      ROMol::VERTEX_ITER atBegin,atEnd;
      boost::tie(atBegin,atEnd) = mol.getVertices();
      while(atBegin!=atEnd){
        ATOM_SPTR at2=mol[*atBegin];
        ... do something with the Atom ...
        ++atBegin;
      }
    \endcode
  */
  ATOM_ITER_PAIR getVertices();
  //! returns an iterator pair for looping over all Bonds
  /*!

    <b>Usage</b>
    \code

      ROMol::EDGE_ITER firstB,lastB;
      boost::tie(firstB,lastB) = mol.getEdges();
      while(firstB!=lastB){
        BOND_SPTR bond = mol[*firstB];
        ... do something with the Bond ...
        ++firstB;
      }
    \endcode
  */
  BOND_ITER_PAIR getEdges();
  //! \overload
  ATOM_ITER_PAIR getVertices() const;
  //! \overload
  BOND_ITER_PAIR getEdges() const;

  //! brief returns a pointer to our underlying BGL object
  /*!
      This can be useful if you need to call other BGL algorithms:

      Here's an example:
      \code
         ... mol is a const ROMol ...
         ... mapping is an INT_VECT ...
         mapping.resize(mol.getNumAtoms());
         const MolGraph &G_p = mol.getTopology();
         int res = boost::connected_components(G_p,&mapping[0]);
      \endcode
   */
  MolGraph const &getTopology() const { return d_graph; }
  //! @}

  //! \name Iterators
  //! @{

  //! get an AtomIterator pointing at our first Atom
  AtomIterator beginAtoms();
  //! \overload
  ConstAtomIterator beginAtoms() const;
  //! get an AtomIterator pointing at the end of our Atoms
  AtomIterator endAtoms();
  //! \overload
  ConstAtomIterator endAtoms() const;
  //! get a BondIterator pointing at our first Bond
  BondIterator beginBonds();
  //! \overload
  ConstBondIterator beginBonds() const;
  //! get a BondIterator pointing at the end of our Bonds
  BondIterator endBonds();
  //! \overload
  ConstBondIterator endBonds() const;

  //! get an AtomIterator pointing at our first aromatic Atom
  AromaticAtomIterator beginAromaticAtoms();
  //! \overload
  ConstAromaticAtomIterator beginAromaticAtoms() const;
  //! get an AtomIterator pointing at the end of our Atoms
  AromaticAtomIterator endAromaticAtoms();
  //! \overload
  ConstAromaticAtomIterator endAromaticAtoms() const;

  //! get an AtomIterator pointing at our first hetero Atom
  HeteroatomIterator beginHeteros();
  //! \overload
  ConstHeteroatomIterator beginHeteros() const;
  //! get an AtomIterator pointing at the end of our Atoms
  HeteroatomIterator endHeteros();
  //! \overload
  ConstHeteroatomIterator endHeteros() const;

  //! get an AtomIterator pointing at our first Atom that matches \c query
  QueryAtomIterator beginQueryAtoms(QueryAtom const *query);
  //! \overload
  ConstQueryAtomIterator beginQueryAtoms(QueryAtom const *) const;
  //! get an AtomIterator pointing at the end of our Atoms
  QueryAtomIterator endQueryAtoms();
  //! \overload
  ConstQueryAtomIterator endQueryAtoms() const;

  //! get an AtomIterator pointing at our first Atom that matches \c query
  MatchingAtomIterator beginMatchingAtoms(bool (*query)(Atom *));
  //! \overload
  ConstMatchingAtomIterator beginMatchingAtoms(
      bool (*query)(const Atom *)) const;
  //! get an AtomIterator pointing at the end of our Atoms
  MatchingAtomIterator endMatchingAtoms();
  //! \overload
  ConstMatchingAtomIterator endMatchingAtoms() const;

  inline ConformerIterator beginConformers() { return d_confs.begin(); }

  inline ConformerIterator endConformers() { return d_confs.end(); }

  inline ConstConformerIterator beginConformers() const {
    return d_confs.begin();
  }

  inline ConstConformerIterator endConformers() const { return d_confs.end(); }

  //! @}

  //! \name Properties
  //! @{

  //! clears all of our \c computed \c properties
  void clearComputedProps(bool includeRings = true) const;
  //! calculates any of our lazy \c properties
  /*!
    <b>Notes:</b>
       - this calls \c updatePropertyCache() on each of our Atoms and Bonds
  */
  void updatePropertyCache(bool strict = true);

  bool needsUpdatePropertyCache() const;

  //! @}

  //! \name Misc
  //! @{
  //! sends some debugging info to a stream
  void debugMol(std::ostream &str) const;
  //! @}

  Atom *operator[](const vertex_descriptor &v) { return d_graph[v]; }
  const Atom *operator[](const vertex_descriptor &v) const {
    return d_graph[v];
  }

  Bond *operator[](const edge_descriptor &e) { return d_graph[e]; }
  const Bond *operator[](const edge_descriptor &e) const { return d_graph[e]; }

  //! Gets a reference to the groups of atoms with relative stereochemistry
  /*!
    Stereo groups are also called enhanced stereochemistry in the SDF/Mol3000
    file format.
  */
  const std::vector<StereoGroup> &getStereoGroups() const {
    return d_stereo_groups;
  }

  //! Sets groups of atoms with relative stereochemistry
  /*!
    \param stereo_groups the new set of stereo groups. All will be replaced.

    Stereo groups are also called enhanced stereochemistry in the SDF/Mol3000
    file format. stereo_groups should be std::move()ed into this function.
  */
  void setStereoGroups(std::vector<StereoGroup> stereo_groups);

#ifdef RDK_USE_BOOST_SERIALIZATION
  //! \name boost::serialization support
  //! @{
  template <class Archive>
  void save(Archive &ar, const unsigned int version) const;
  template <class Archive>
  void load(Archive &ar, const unsigned int version);
  BOOST_SERIALIZATION_SPLIT_MEMBER()
  //! @}
#endif

 private:
  MolGraph d_graph;
  ATOM_BOOKMARK_MAP d_atomBookmarks;
  BOND_BOOKMARK_MAP d_bondBookmarks;
  RingInfo *dp_ringInfo = nullptr;
  CONF_SPTR_LIST d_confs;
  std::vector<SubstanceGroup> d_sgroups;
  std::vector<StereoGroup> d_stereo_groups;
  std::unique_ptr<boost::dynamic_bitset<>> dp_delAtoms = nullptr;
  std::unique_ptr<boost::dynamic_bitset<>> dp_delBonds = nullptr;

  friend RDKIT_GRAPHMOL_EXPORT std::vector<SubstanceGroup> &getSubstanceGroups(
      ROMol &);
  friend RDKIT_GRAPHMOL_EXPORT const std::vector<SubstanceGroup>
      &getSubstanceGroups(const ROMol &);
  void clearSubstanceGroups() { d_sgroups.clear(); }

 protected:
  unsigned int numBonds{0};
#ifndef WIN32
 private:
#endif
  void initMol();
  virtual void destroy();
  //! adds an Atom to our collection
  /*!
    \param atom          pointer to the Atom to add
    \param updateLabel   (optional) if this is true, the new Atom will be
                         our \c activeAtom
    \param takeOwnership (optional) if this is true, we take ownership of \c
    atom
                         instead of copying it.

    \return the index of the new atom
  */
  unsigned int addAtom(Atom *atom, bool updateLabel = true,
                       bool takeOwnership = false);
  //! adds a Bond to our collection
  /*!
    \param bond          pointer to the Bond to add
    \param takeOwnership (optional) if this is true, we take ownership of \c
    bond
                         instead of copying it.

    \return the new number of bonds
  */
  unsigned int addBond(Bond *bond, bool takeOwnership = false);

  //! adds a Bond to our collection
  /*!
    \param bond          pointer to the Bond to add

    \return the new number of bonds

    <b>Note:</b> since this is using a smart pointer, we don't need to worry
    about
    issues of ownership.
  */
  void initFromOther(const ROMol &other, bool quickCopy, int confId);
};

typedef std::vector<ROMol> MOL_VECT;
typedef boost::shared_ptr<ROMol> ROMOL_SPTR;
typedef std::vector<ROMol *> MOL_PTR_VECT;
typedef std::vector<ROMOL_SPTR> MOL_SPTR_VECT;

typedef MOL_PTR_VECT::const_iterator MOL_PTR_VECT_CI;
typedef MOL_PTR_VECT::iterator MOL_PTR_VECT_I;

};  // namespace RDKit
#endif