anchor.diff:  
   <%0.upto(GENERATION_LIMIT) {|i|%>
   template <typename A0<%1.upto(i) {|j|%>, typename A<%=j%><%}%>>
  -tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(const A0& a0<%1.upto(i) {|j|%>, const A<%=j%>& a<%=j%><%}%>)
  +tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>> make_tuple(typename tuple_type<A0>::transparent_reference a0<%1.upto(i) {|j|%>, typename tuple_type<A<%=j%>>::transparent_reference a<%=j%><%}%>)
   {
   	return tuple<A0<%1.upto(i) {|j|%>, A<%=j%><%}%>>(a0<%1.upto(i) {|j|%>, a<%=j%><%}%>);
   }
  
positive.code: <%}%>
  
  
  // FIXME
  /*
  template <typename A0, typename A1 = void, typename A2 = void>
  struct tuple_just;
  
  template <typename A0>
  struct tuple_just<A0> {
  	A0 a0;
  	static inline void convert(object o, tuple_just<A0>& v)
  	{
  		if(o.type != type::ARRAY) { throw type_error(); }
  		if(o.v.container.size != 1) { throw type_error(); }
  		msgpack::convert<A0>(o.v.container.ptr[0], v.a0);
  	}
  };
  
  template <typename A0, typename A1>
  struct tuple_just<A0, A1> {
  	A0 a0;
  	A1 a1;
  	static inline void convert(object o, tuple_just<A0, A1>& v)
  	{
  		if(o.type != type::ARRAY) { throw type_error(); }
  		if(o.v.container.size != 2) { throw type_error(); }
  		msgpack::convert<A0>(o.v.container.ptr[0], v.a0);
  		msgpack::convert<A1>(o.v.container.ptr[1], v.a1);
  	}
  };
  */
  
  
  }  // namespace msgpack
  
  #endif /* msgpack/type/tuple.hpp */
  
negative.code: struct tuple;
  
  template <typename Tuple, int N>
  struct tuple_element;
  
  template <typename Tuple, int N>
  struct const_tuple_element;
  
  template <typename T>
  struct tuple_type {
  	typedef T type;
  	typedef T value_type;
  	typedef T& reference;
  	typedef const T& const_reference;
  	typedef const T& transparent_reference;
  };
  
  template <typename T>
  struct tuple_type<T&> {
  	typedef T type;
  	typedef T& value_type;
  	typedef T& reference;
  	typedef const T& const_reference;
  	typedef T& transparent_reference;
  };
  
  template <typename T>
  struct tuple_type<const T&> {
  	typedef T type;
  	typedef T& value_type;
  	typedef T& reference;
  	typedef const T& const_reference;
  	typedef const T& transparent_reference;
  };
  
  
  <%0.upto(GENERATION_LIMIT) {|i|%>
  <%0.upto(i) {|j|%>
  template <typename A0<%1.upto(i) {|k|%>, typename A<%=k%><%}%>>
  struct tuple_element<tuple<A0<%1.upto(i) {|k|%>, A<%=k%><%}%>>, <%=j%>> : tuple_type<A<%=j%>> {
  	tuple_element(tuple<A0<%1.upto(i) {|k|%>, A<%=k%> <%}%>>& x) : _x(x.a<%=j%>) {}
  	typename tuple_type<A<%=j%>>::reference get() { return _x; }
  	typename tuple_type<A<%=j%>>::const_reference get() const { return _x; }
  private:
  	typename tuple_type<A<%=j%>>::reference _x;
  };
  <%}%>
  <%}%>
  