anchor.diff:  <%0.upto(GENERATION_LIMIT) {|i|%>
   template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
   struct tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> {
  +	typedef tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> value_type;
   	tuple() {}
  -	tuple(const A0& _a0<%1.upto(i) {|j|%>, const A<%=j%>& _a<%=j%><%}%>) :
  -		a0(_a0) <%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
  +	tuple(typename tuple_type<A0>::transparent_reference _a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference _a<%=j%><%}%>) :
  +		a0(_a0)<%1.upto(i) {|j|%>, a<%=j%>(_a<%=j%>)<%}%> {}
   	tuple(object o) { convert(*this, o); }
  -	template <int N> typename tuple_type<tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::type& get()
  -		{ return tuple_type<tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>(*this).get(); }
  -	template <int N> const typename const_tuple_type<tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>::type& get() const
  -		{ return const_tuple_type<tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>, N>(*this).get(); }
  +	template <int N> typename tuple_element<value_type, N>::reference get()
  +		{ return tuple_element<value_type, N>(*this).get(); }
  +	template <int N> typename const_tuple_element<value_type, N>::const_reference get() const
  +		{ return const_tuple_element<value_type, N>(*this).get(); }
   	<%0.upto(i) {|j|%>
   	A<%=j%> a<%=j%>;<%}%>
   };
  
positive.code: <%0.upto(GENERATION_LIMIT) {|i|%>
  <%0.upto(i) {|j|%>
  template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
  struct const_tuple_type<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : const_tuple_element<A<%=j%>> {
  	const_tuple_type(const tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>& x) : const_tuple_element<A<%=j%>>(x.a<%=j%>) {}
  };
  <%}%>
  <%}%>
  
negative.code: <%}%>
  
  
  }  // namespace msgpack
  
  #endif /* msgpack/type/tuple.hpp */
  