diff --git a/include/msgpack/unpack.hpp b/include/msgpack/unpack.hpp
index 60df2f6d..652bbcbd 100644
--- a/include/msgpack/unpack.hpp
+++ b/include/msgpack/unpack.hpp
@@ -820,7 +820,7 @@ struct unpack_error : public std::runtime_error {
 
 class unpacked {
 public:
-    unpacked():m_referenced(false) { }
+    unpacked() {}
 
     unpacked(object const& obj, msgpack::unique_ptr<msgpack::zone> z) :
         m_obj(obj), m_zone(msgpack::move(z)) { }
@@ -837,12 +837,6 @@ public:
     const msgpack::unique_ptr<msgpack::zone>& zone() const
         { return m_zone; }
 
-    void set_referenced(bool r)
-        { m_referenced = r; }
-
-    bool referenced() const
-        { return m_referenced; }
-
 private:
     object m_obj;
     msgpack::unique_ptr<msgpack::zone> m_zone;
@@ -876,6 +870,7 @@ public:
 
     /*! 4. repeat next() until it retunrs false */
     bool next(unpacked* result);
+    bool next(unpacked& result, bool& referenced);
     bool next(unpacked& result);
 
     /*! 5. check if the size of message doesn't exceed assumption. */
@@ -970,16 +965,22 @@ private:
     unpacker& operator=(const unpacker&);
 };
 
+inline void unpack(unpacked& result,
+                   const char* data, std::size_t len, std::size_t& off, bool& referenced,
+                   unpack_reference_func f = nullptr, void* user_data = nullptr);
 inline void unpack(unpacked& result,
                    const char* data, std::size_t len, std::size_t& off,
                    unpack_reference_func f = nullptr, void* user_data = nullptr);
+inline void unpack(unpacked& result,
+                   const char* data, std::size_t len, bool& referenced,
+                   unpack_reference_func f = nullptr, void* user_data = nullptr);
 inline void unpack(unpacked& result,
                    const char* data, std::size_t len,
                    unpack_reference_func f = nullptr, void* user_data = nullptr);
 
 // obsolete
 inline void unpack(unpacked* result,
-                   const char* data, std::size_t len, std::size_t* off = nullptr,
+                   const char* data, std::size_t len, std::size_t* off = nullptr, bool* referenced = nullptr,
                    unpack_reference_func f = nullptr, void* user_data = nullptr);
 
 
@@ -1134,10 +1135,10 @@ inline void unpacker::buffer_consumed(std::size_t size)
     m_free -= size;
 }
 
-inline bool unpacker::next(unpacked& result)
+inline bool unpacker::next(unpacked& result, bool& referenced)
 {
+    referenced = false;
     int ret = execute_imp();
-
     if(ret < 0) {
         throw unpack_error("parse error");
     }
@@ -1148,7 +1149,7 @@ inline bool unpacker::next(unpacked& result)
         return false;
 
     } else {
-        result.set_referenced(m_ctx.user().referenced());
+        referenced = m_ctx.user().referenced();
         result.zone().reset( release_zone() );
         result.set(data());
         reset();
@@ -1156,6 +1157,12 @@ inline bool unpacker::next(unpacked& result)
     }
 }
 
+inline bool unpacker::next(unpacked& result)
+{
+    bool referenced;
+    return next(result, referenced);
+}
+
 inline bool unpacker::next(unpacked* result)
 {
     return next(*result);
@@ -1307,17 +1314,15 @@ unpack_imp(const char* data, std::size_t len, std::size_t& off,
 
 // reference version
 inline void unpack(unpacked& result,
-                   const char* data, std::size_t len, std::size_t& off,
+                   const char* data, std::size_t len, std::size_t& off, bool& referenced,
                    unpack_reference_func f, void* user_data)
 {
     object obj;
     msgpack::unique_ptr<zone> z(new zone);
-    bool referenced = false;
+    referenced = false;
     unpack_return ret = detail::unpack_imp(
         data, len, off, *z, obj, referenced, f, user_data);
 
-    result.set_referenced(referenced);
-
     switch(ret) {
     case UNPACK_SUCCESS:
         result.set(obj);
@@ -1336,21 +1341,42 @@ inline void unpack(unpacked& result,
 }
 
 inline void unpack(unpacked& result,
-                   const char* data, std::size_t len,
+                   const char* data, std::size_t len, std::size_t& off,
+                   unpack_reference_func f, void* user_data)
+{
+    bool referenced;
+    unpack(result, data, len, off, referenced, f, user_data);
+}
+
+inline void unpack(unpacked& result,
+                   const char* data, std::size_t len, bool& referenced,
                    unpack_reference_func f, void* user_data)
 {
     std::size_t off = 0;
-    unpack(result, data, len, off, f, user_data);
+    unpack(result, data, len, off, referenced, f, user_data);
+}
+
+inline void unpack(unpacked& result,
+                   const char* data, std::size_t len,
+                   unpack_reference_func f, void* user_data)
+{
+    bool referenced;
+    std::size_t off = 0;
+    unpack(result, data, len, off, referenced, f, user_data);
 }
 
 // obsolete
 // pointer version
 inline void unpack(unpacked* result,
-                   const char* data, std::size_t len, std::size_t* off,
+                   const char* data, std::size_t len, std::size_t* off, bool* referenced,
                    unpack_reference_func f, void* user_data)
 {
-    if (off) unpack(*result, data, len, *off);
-    else unpack(*result, data, len, f, user_data);
+    if (off)
+        if (referenced) unpack(*result, data, len, *off, *referenced, f, user_data);
+        else unpack(*result, data, len, *off, f, user_data);
+    else
+        if (referenced) unpack(*result, data, len, *referenced, f, user_data);
+        else unpack(*result, data, len, f, user_data);
 }
 
 bool unpacker::default_reference_func(type::object_type type, uint64_t len, void*)
diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp
index f47aeeee..bef5f93a 100644
--- a/test/msgpack_test.cpp
+++ b/test/msgpack_test.cpp
@@ -38,7 +38,6 @@ const double kEPS = 1e-10;
       msgpack::unpacked ret;                                          \
       msgpack::unpack(ret, sbuf.data(), sbuf.size());                 \
       EXPECT_EQ(val1, ret.get().as<test_type>());                     \
-      EXPECT_FALSE(ret.referenced());                                 \
     }                                                                 \
 } while(0)
 
@@ -206,7 +205,6 @@ TYPED_TEST_P(IntegerToFloatingPointTest, simple_buffer)
     msgpack::unpack(ret, sbuf.data(), sbuf.size());
     float_type val2 = ret.get().as<float_type>();
     EXPECT_TRUE(fabs(val2 - val1) <= kEPS);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -244,7 +242,6 @@ TEST(MSGPACK, simple_buffer_double)
     msgpack::unpacked ret;
     msgpack::unpack(ret, sbuf.data(), sbuf.size());
     double val2 = ret.get().as<double>();
-    EXPECT_FALSE(ret.referenced());
 
     if (std::isnan(val1))
       EXPECT_TRUE(std::isnan(val2));
@@ -264,7 +261,6 @@ TEST(MSGPACK, simple_buffer_true)
   msgpack::unpack(ret, sbuf.data(), sbuf.size());
   bool val2 = ret.get().as<bool>();
   EXPECT_EQ(val1, val2);
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_false)
@@ -276,7 +272,6 @@ TEST(MSGPACK, simple_buffer_false)
   msgpack::unpack(ret, sbuf.data(), sbuf.size());
   bool val2 = ret.get().as<bool>();
   EXPECT_EQ(val1, val2);
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext1)
@@ -292,7 +287,6 @@ TEST(MSGPACK, simple_buffer_fixext1)
   EXPECT_EQ(1, ret.get().via.ext.size);
   EXPECT_EQ(1, ret.get().via.ext.type());
   EXPECT_EQ(2, ret.get().via.ext.data()[0]);
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext2)
@@ -309,7 +303,6 @@ TEST(MSGPACK, simple_buffer_fixext2)
   EXPECT_EQ(0, ret.get().via.ext.type());
   EXPECT_TRUE(
       std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext4)
@@ -326,7 +319,6 @@ TEST(MSGPACK, simple_buffer_fixext4)
   EXPECT_EQ(1, ret.get().via.ext.type());
   EXPECT_TRUE(
       std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext8)
@@ -343,7 +335,6 @@ TEST(MSGPACK, simple_buffer_fixext8)
   EXPECT_EQ(1, ret.get().via.ext.type());
   EXPECT_TRUE(
       std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext16)
@@ -360,7 +351,6 @@ TEST(MSGPACK, simple_buffer_fixext16)
   EXPECT_EQ(1, ret.get().via.ext.type());
   EXPECT_TRUE(
       std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_1byte_0)
@@ -374,7 +364,6 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_0)
   msgpack::unpack(ret, sbuf.data(), sbuf.size());
   EXPECT_EQ(size, ret.get().via.ext.size);
   EXPECT_EQ(77, ret.get().via.ext.type());
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_1byte_255)
@@ -393,7 +382,6 @@ TEST(MSGPACK, simple_buffer_fixext_1byte_255)
   EXPECT_EQ(77, ret.get().via.ext.type());
   EXPECT_TRUE(
       std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_2byte_256)
@@ -412,7 +400,6 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_256)
   EXPECT_EQ(77, ret.get().via.ext.type());
   EXPECT_TRUE(
       std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
@@ -431,7 +418,6 @@ TEST(MSGPACK, simple_buffer_fixext_2byte_65535)
   EXPECT_EQ(77, ret.get().via.ext.type());
   EXPECT_TRUE(
       std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
-  EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
@@ -450,7 +436,6 @@ TEST(MSGPACK, simple_buffer_fixext_4byte_65536)
   EXPECT_EQ(77, ret.get().via.ext.type());
   EXPECT_TRUE(
       std::equal(buf, buf + sizeof(buf), ret.get().via.ext.data()));
-  EXPECT_FALSE(ret.referenced());
 }
 
 //-----------------------------------------------------------------------------
@@ -471,7 +456,6 @@ TEST(MSGPACK_STL, simple_buffer_string)
     string val2 = ret.get().as<string>();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_EQ(val1, val2);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -489,7 +473,6 @@ TEST(MSGPACK_STL, simple_buffer_vector)
     vector<int> val2 = ret.get().as<vector<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -523,7 +506,6 @@ TEST(MSGPACK_STL, simple_buffer_map)
     map<int, int> val2 = ret.get().as<map<int, int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -540,7 +522,6 @@ TEST(MSGPACK_STL, simple_buffer_deque)
     deque<int> val2 = ret.get().as<deque<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -557,7 +538,6 @@ TEST(MSGPACK_STL, simple_buffer_list)
     list<int> val2 = ret.get().as<list<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -574,7 +554,6 @@ TEST(MSGPACK_STL, simple_buffer_set)
     set<int> val2 = ret.get().as<set<int> >();
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -589,7 +568,6 @@ TEST(MSGPACK_STL, simple_buffer_pair)
     pair<int, int> val2 = ret.get().as<pair<int, int> >();
     EXPECT_EQ(val1.first, val2.first);
     EXPECT_EQ(val1.second, val2.second);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -619,7 +597,6 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
     sort(v1.begin(), v1.end());
     sort(v2.begin(), v2.end());
     EXPECT_TRUE(v1 == v2);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -646,7 +623,6 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
     sort(v1.begin(), v1.end());
     sort(v2.begin(), v2.end());
     EXPECT_TRUE(v1 == v2);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -672,7 +648,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
       EXPECT_TRUE(val2.find(it->first) != val2.end());
       EXPECT_EQ(it->second, val2.find(it->first)->second);
     }
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -702,7 +677,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
     sort(v1.begin(), v1.end());
     sort(v2.begin(), v2.end());
     EXPECT_TRUE(v1 == v2);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 #endif
@@ -725,7 +699,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
     tr1::unordered_set<int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it)
       EXPECT_TRUE(val2.find(*it) != val2.end());
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -752,7 +725,6 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
     sort(v1.begin(), v1.end());
     sort(v2.begin(), v2.end());
     EXPECT_TRUE(v1 == v2);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 #endif
@@ -777,7 +749,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_map)
       EXPECT_TRUE(val2.find(it->first) != val2.end());
       EXPECT_EQ(it->second, val2.find(it->first)->second);
     }
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -807,7 +778,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multimap)
     sort(v1.begin(), v1.end());
     sort(v2.begin(), v2.end());
     EXPECT_TRUE(v1 == v2);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 #endif
@@ -830,7 +800,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_set)
     unordered_set<int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it)
       EXPECT_TRUE(val2.find(*it) != val2.end());
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -857,7 +826,6 @@ TEST(MSGPACK_TR1, simple_buffer_unordered_multiset)
     sort(v1.begin(), v1.end());
     sort(v2.begin(), v2.end());
     EXPECT_TRUE(v1 == v2);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 #endif
@@ -885,7 +853,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
     TestClass val2 = ret.get().as<TestClass>();
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -914,7 +881,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
     EXPECT_FALSE(val2.s.empty());
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -965,7 +931,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
   EXPECT_EQ(val1.t1, val2.t1);
   EXPECT_EQ(val1.t2, val2.t2);
   EXPECT_EQ(val1.t3, val2.t3);
-  EXPECT_FALSE(ret.referenced());
 }
 
 class TestUnionMemberClass
@@ -1021,7 +986,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
     TestUnionMemberClass val2 = ret.get().as<TestUnionMemberClass>();
     EXPECT_EQ(val1.is_double, val2.is_double);
     EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
-    EXPECT_FALSE(ret.referenced());
   }
   {
     // int
@@ -1034,7 +998,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
     EXPECT_EQ(val1.is_double, val2.is_double);
     EXPECT_EQ(val1.value.i, 1);
     EXPECT_EQ(val1.value.i, val2.value.i);
-    EXPECT_FALSE(ret.referenced());
   }
 }
 
@@ -1056,7 +1019,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
       msgpack::unpack(ret, sbuf.data(), sbuf.size());                   \
       test_type val2 = ret.get().as<test_type>();                       \
       EXPECT_EQ(val1, val2);                                            \
-      EXPECT_FALSE(ret.referenced());                                   \
     }                                                                   \
   } while(0);
 
diff --git a/test/msgpack_test_cpp11.cpp b/test/msgpack_test_cpp11.cpp
index 0d13123b..d06b184c 100644
--- a/test/msgpack_test_cpp11.cpp
+++ b/test/msgpack_test_cpp11.cpp
@@ -25,7 +25,6 @@ TEST(MSGPACK_CPP11, simple_tuple)
     msgpack::unpack(ret, sbuf.data(), sbuf.size());
     std::tuple<bool, std::string, double> val2 = ret.get().as<std::tuple<bool, std::string, double> >();
     EXPECT_EQ(val1, val2);
-    EXPECT_FALSE(ret.referenced());
 }
 
 TEST(MSGPACK_CPP11, simple_array)
@@ -42,7 +41,6 @@ TEST(MSGPACK_CPP11, simple_array)
         array<int, kElements> val2 = ret.get().as<array<int, kElements> >();
         EXPECT_EQ(val1.size(), val2.size());
         EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
-        EXPECT_FALSE(ret.referenced());
     }
 }
 
@@ -75,7 +73,6 @@ TEST(MSGPACK_STL, simple_buffer_forward_list)
         msgpack::unpack(ret, sbuf.data(), sbuf.size());
         forward_list<int> val2 = ret.get().as<forward_list<int> >();
         EXPECT_EQ(val1, val2);
-        EXPECT_FALSE(ret.referenced());
     }
 }
 
@@ -112,7 +109,6 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_class_member)
     EXPECT_EQ(val1.t1, val2.t1);
     EXPECT_EQ(val1.t2, val2.t2);
     EXPECT_EQ(val1.t3, val2.t3);
-    EXPECT_FALSE(ret.referenced());
 }
 
 #endif // !defined(MSGPACK_USE_CPP03)
diff --git a/test/reference.cpp b/test/reference.cpp
index 09ecbca5..7c338a38 100644
--- a/test/reference.cpp
+++ b/test/reference.cpp
@@ -6,9 +6,10 @@ TEST(reference, unpack_int)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
     msgpack::unpacked ret;
+    bool referenced;
 
-    msgpack::unpack(ret, sbuf.data(), sbuf.size());
-    EXPECT_FALSE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced);
+    EXPECT_FALSE(referenced);
 }
 
 TEST(reference, unpack_string)
@@ -16,9 +17,10 @@ TEST(reference, unpack_string)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("abcdefg"));
     msgpack::unpacked ret;
+    bool referenced;
 
-    msgpack::unpack(ret, sbuf.data(), sbuf.size());
-    EXPECT_FALSE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced);
+    EXPECT_FALSE(referenced);
 }
 
 TEST(reference, unpack_bin)
@@ -30,8 +32,9 @@ TEST(reference, unpack_bin)
     packer.pack_bin_body(c, sizeof(c));
 
     msgpack::unpacked ret;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size());
-    EXPECT_FALSE(ret.referenced());
+    bool referenced;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced);
+    EXPECT_FALSE(referenced);
 }
 
 TEST(reference, unpack_ext)
@@ -43,8 +46,9 @@ TEST(reference, unpack_ext)
     packer.pack_ext(sizeof(buf), 1);
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::unpacked ret;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size());
-    EXPECT_FALSE(ret.referenced());
+    bool referenced;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced);
+    EXPECT_FALSE(referenced);
 }
 
 bool never_called(msgpack::type::object_type, std::size_t, void*)
@@ -63,9 +67,10 @@ TEST(reference, unpack_int_ref)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, 1);
     msgpack::unpacked ret;
+    bool referenced;
 
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called);
-    EXPECT_FALSE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called);
+    EXPECT_FALSE(referenced);
 }
 
 TEST(reference, unpack_string_ref)
@@ -73,9 +78,11 @@ TEST(reference, unpack_string_ref)
     msgpack::sbuffer sbuf;
     msgpack::pack(sbuf, std::string("abcdefg"));
     msgpack::unpacked ret;
+    bool referenced;
 
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
-    EXPECT_TRUE(ret.referenced());
+
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference);
+    EXPECT_TRUE(referenced);
 }
 
 TEST(reference, unpack_bin_ref)
@@ -87,8 +94,9 @@ TEST(reference, unpack_bin_ref)
     packer.pack_bin_body(c, sizeof(c));
 
     msgpack::unpacked ret;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
-    EXPECT_TRUE(ret.referenced());
+    bool referenced;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference);
+    EXPECT_TRUE(referenced);
 }
 
 TEST(reference, unpack_ext_ref)
@@ -100,8 +108,9 @@ TEST(reference, unpack_ext_ref)
     packer.pack_ext(sizeof(buf), 1);
     packer.pack_ext_body(buf, sizeof(buf));
     msgpack::unpacked ret;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), always_reference);
-    EXPECT_TRUE(ret.referenced());
+    bool referenced;
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, always_reference);
+    EXPECT_TRUE(referenced);
 }
 
 static void* s_p;
@@ -131,9 +140,10 @@ TEST(reference, unpack_int_sized_ref)
     msgpack::pack(sbuf, 1);
 
     msgpack::unpacked ret;
+    bool referenced;
     s_p = nullptr;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), never_called, &sbuf);
-    EXPECT_FALSE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, never_called, &sbuf);
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(nullptr, s_p);
 }
 
@@ -143,11 +153,12 @@ TEST(reference, unpack_string_sized_ref_4)
     msgpack::pack(sbuf, std::string("1234"));
 
     msgpack::unpacked ret;
+    bool referenced;
     s_p = nullptr;
     // the last argument sbuf is any pointer as a user data.
     // That is stored to s_p in sized_reference
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
-    EXPECT_FALSE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
+    EXPECT_FALSE(referenced);
     // compare the passed argument with stored s_p.
     EXPECT_EQ(&sbuf, s_p);
 }
@@ -158,9 +169,10 @@ TEST(reference, unpack_string_sized_ref_5)
     msgpack::pack(sbuf, std::string("12345"));
 
     msgpack::unpacked ret;
+    bool referenced;
     s_p = nullptr;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
-    EXPECT_TRUE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
+    EXPECT_TRUE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -174,9 +186,10 @@ TEST(reference, unpack_bin_sized_ref_5)
     packer.pack_bin_body(c, sizeof(c));
 
     msgpack::unpacked ret;
+    bool referenced;
     s_p = nullptr;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
-    EXPECT_FALSE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -189,9 +202,10 @@ TEST(reference, unpack_bin_sized_ref_6)
     packer.pack_bin_body(c, sizeof(c));
 
     msgpack::unpacked ret;
+    bool referenced;
     s_p = nullptr;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
-    EXPECT_TRUE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
+    EXPECT_TRUE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -205,9 +219,10 @@ TEST(reference, unpack_ext_sized_ref_6)
     packer.pack_ext_body(buf, sizeof(buf));
 
     msgpack::unpacked ret;
+    bool referenced;
     s_p = nullptr;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
-    EXPECT_FALSE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -221,9 +236,10 @@ TEST(reference, unpack_ext_sized_ref_7)
     packer.pack_ext_body(buf, sizeof(buf));
 
     msgpack::unpacked ret;
+    bool referenced;
     s_p = nullptr;
-    msgpack::unpack(ret, sbuf.data(), sbuf.size(), sized_reference, &sbuf);
-    EXPECT_TRUE(ret.referenced());
+    msgpack::unpack(ret, sbuf.data(), sbuf.size(), referenced, sized_reference, &sbuf);
+    EXPECT_TRUE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -237,12 +253,13 @@ TEST(reference, unpacker_int)
 
     msgpack::unpacker unp;
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_FALSE(ret.referenced());
+    EXPECT_FALSE(referenced);
 }
 
 TEST(reference, unpacker_string)
@@ -252,12 +269,13 @@ TEST(reference, unpacker_string)
 
     msgpack::unpacker unp;
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_TRUE(ret.referenced());
+    EXPECT_TRUE(referenced);
 }
 
 TEST(reference, unpacker_bin)
@@ -270,12 +288,13 @@ TEST(reference, unpacker_bin)
 
     msgpack::unpacker unp;
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_TRUE(ret.referenced());
+    EXPECT_TRUE(referenced);
 }
 
 TEST(reference, unpacker_ext)
@@ -289,12 +308,13 @@ TEST(reference, unpacker_ext)
 
     msgpack::unpacker unp;
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_TRUE(ret.referenced());
+    EXPECT_TRUE(referenced);
 }
 
 // pass user custom reference function
@@ -306,13 +326,14 @@ TEST(reference, unpacker_int_sized_ref)
 
     msgpack::unpacker unp(never_called, &sbuf);
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     s_p = nullptr;
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_FALSE(ret.referenced());
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(nullptr, s_p);
 }
 
@@ -323,13 +344,14 @@ TEST(reference, unpacker_string_sized_ref_4)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     s_p = nullptr;
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_FALSE(ret.referenced());
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -340,13 +362,14 @@ TEST(reference, unpacker_string_sized_ref_5)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     s_p = nullptr;
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_TRUE(ret.referenced());
+    EXPECT_TRUE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -361,13 +384,14 @@ TEST(reference, unpacker_bin_sized_ref_5)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     s_p = nullptr;
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_FALSE(ret.referenced());
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -381,13 +405,14 @@ TEST(reference, unpacker_bin_sized_ref_6)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     s_p = nullptr;
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_TRUE(ret.referenced());
+    EXPECT_TRUE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -402,13 +427,14 @@ TEST(reference, unpacker_ext_sized_ref_6)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     s_p = nullptr;
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_FALSE(ret.referenced());
+    EXPECT_FALSE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }
 
@@ -423,12 +449,13 @@ TEST(reference, unpacker_ext_sized_ref_7)
 
     msgpack::unpacker unp(sized_reference, &sbuf);
     msgpack::unpacked ret;
+    bool referenced;
     unp.reserve_buffer(sbuf.size());
     std::memcpy(unp.buffer(), sbuf.data(), sbuf.size());
     unp.buffer_consumed(sbuf.size());
     s_p = nullptr;
-    bool b = unp.next(ret);
+    bool b = unp.next(ret, referenced);
     EXPECT_TRUE(b);
-    EXPECT_TRUE(ret.referenced());
+    EXPECT_TRUE(referenced);
     EXPECT_EQ(&sbuf, s_p);
 }