diff --git a/example/speed_test.cc b/example/speed_test.cc
index 589fbe40..1758ad5b 100644
--- a/example/speed_test.cc
+++ b/example/speed_test.cc
@@ -31,7 +31,7 @@ void test_map_pack_unpack() {
 	std::cout << "Start unpacking..." << std::endl;
 	{
 		boost::timer::cpu_timer timer;
-		msgpack::unpack(str.data(), str.size(), NULL, mempool, deserialized);
+		msgpack::unpack(str.data(), str.size(), NULL, &mempool, &deserialized);
 		std::string result = timer.format();
 		std::cout << result << std::endl;
 	}
@@ -41,11 +41,20 @@ void test_map_pack_unpack() {
 	std::cout << "Start unpacking...by void unpack(unpacked* result, const char* data, size_t len, size_t* offset = NULL)" << std::endl;
 	{
 		boost::timer::cpu_timer timer;
-		msgpack::unpack(unpacked, str.data(), str.size());
+		msgpack::unpack(&unpacked, str.data(), str.size());
 		std::string result = timer.format();
 		std::cout << result << std::endl;
 	}
 	std::cout << "Unpack finished..." << std::endl;
+	std::map<int, int> m2;
+	std::cout << "Start converting..." << std::endl;
+	{
+		boost::timer::cpu_timer timer;
+		deserialized.convert(&m2);
+		std::string result = timer.format();
+		std::cout << result << std::endl;
+	}
+	std::cout << "Convert finished..." << std::endl;
 }
 
 
diff --git a/test/convert.cc b/test/convert.cc
index e875b749..f579f33a 100644
--- a/test/convert.cc
+++ b/test/convert.cc
@@ -20,7 +20,7 @@ TEST(convert, compatibility_less)
 	msgpack::object obj(src, &z);
 
 	compatibility c;
-	EXPECT_NO_THROW( obj.convert(c) );
+	EXPECT_NO_THROW( obj.convert(&c) );
 
 	EXPECT_EQ("kumofs",  c.str1);
 	EXPECT_EQ("default", c.str2);
@@ -37,7 +37,7 @@ TEST(convert, compatibility_more)
 	msgpack::object obj(src, &z);
 
 	compatibility to;
-	EXPECT_NO_THROW( obj.convert(to) );
+	EXPECT_NO_THROW( obj.convert(&to) );
 
 	EXPECT_EQ("kumofs", to.str1);
 	EXPECT_EQ("mpio",   to.str2);
@@ -69,7 +69,7 @@ TEST(convert, enum_member)
 	msgpack::object obj(src, &z);
 
 	enum_member to;
-	EXPECT_NO_THROW( obj.convert(to) );
+	EXPECT_NO_THROW( obj.convert(&to) );
 
 	EXPECT_EQ(enum_member::B, to.flag);
 }
diff --git a/test/fixint.cc b/test/fixint.cc
index a68d759a..63288a1b 100644
--- a/test/fixint.cc
+++ b/test/fixint.cc
@@ -30,10 +30,10 @@ void check_convert() {
 	msgpack::pack(sbuf, v1);
 
 	msgpack::unpacked msg;
-	msgpack::unpack(msg, sbuf.data(), sbuf.size());
+	msgpack::unpack(&msg, sbuf.data(), sbuf.size());
 
 	T v2;
-	msg.get().convert(v2);
+	msg.get().convert(&v2);
 
 	EXPECT_EQ(v1.get(), v2.get());
 
diff --git a/test/msgpack_test.cpp b/test/msgpack_test.cpp
index 37904952..d9a40500 100644
--- a/test/msgpack_test.cpp
+++ b/test/msgpack_test.cpp
@@ -38,10 +38,10 @@ const double kEPS = 1e-10;
       msgpack::zone z;                                                \
       msgpack::object obj;                                            \
       msgpack::unpack_return ret =                                    \
-        msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);    \
+        msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);    \
       EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);                        \
       test_type val2;                                                 \
-      obj.convert(val2);                                             \
+      obj.convert(&val2);                                             \
       EXPECT_EQ(val1, val2);                                          \
     }                                                                 \
 } while(0)
@@ -165,10 +165,10 @@ TEST(MSGPACK, simple_buffer_float)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     float val2;
-    obj.convert(val2);
+    obj.convert(&val2);
 
     if (std::isnan(val1))
       EXPECT_TRUE(std::isnan(val2));
@@ -255,10 +255,10 @@ TEST(MSGPACK, simple_buffer_double)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     double val2;
-    obj.convert(val2);
+    obj.convert(&val2);
 
     if (std::isnan(val1))
       EXPECT_TRUE(std::isnan(val2));
@@ -277,10 +277,10 @@ TEST(MSGPACK, simple_buffer_true)
   msgpack::zone z;
   msgpack::object obj;
   msgpack::unpack_return ret =
-    msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+    msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   bool val2;
-  obj.convert(val2);
+  obj.convert(&val2);
   EXPECT_EQ(val1, val2);
 }
 
@@ -292,10 +292,10 @@ TEST(MSGPACK, simple_buffer_false)
   msgpack::zone z;
   msgpack::object obj;
   msgpack::unpack_return ret =
-    msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+    msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   bool val2;
-  obj.convert(val2);
+  obj.convert(&val2);
   EXPECT_EQ(val1, val2);
 }
 
@@ -314,10 +314,10 @@ TEST(MSGPACK_STL, simple_buffer_string)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     string val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_EQ(val1, val2);
   }
@@ -334,10 +334,10 @@ TEST(MSGPACK_STL, simple_buffer_vector)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     vector<int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -354,10 +354,10 @@ TEST(MSGPACK_STL, simple_buffer_map)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     map<int, int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -374,10 +374,10 @@ TEST(MSGPACK_STL, simple_buffer_deque)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     deque<int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -394,10 +394,10 @@ TEST(MSGPACK_STL, simple_buffer_list)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     list<int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -414,10 +414,10 @@ TEST(MSGPACK_STL, simple_buffer_set)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     set<int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.size(), val2.size());
     EXPECT_TRUE(equal(val1.begin(), val1.end(), val2.begin()));
   }
@@ -432,10 +432,10 @@ TEST(MSGPACK_STL, simple_buffer_pair)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     pair<int, int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.first, val2.first);
     EXPECT_EQ(val1.second, val2.second);
   }
@@ -455,10 +455,10 @@ TEST(MSGPACK_STL, simple_buffer_multimap)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     multimap<int, int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
 
     vector<pair<int, int> > v1, v2;
     multimap<int, int>::const_iterator it;
@@ -485,10 +485,10 @@ TEST(MSGPACK_STL, simple_buffer_multiset)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     multiset<int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
 
     vector<int> v1, v2;
     multiset<int>::const_iterator it;
@@ -520,10 +520,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_map)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_map<int, int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.size(), val2.size());
     tr1::unordered_map<int, int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it) {
@@ -547,10 +547,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multimap)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_multimap<int, int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
 
     vector<pair<int, int> > v1, v2;
     tr1::unordered_multimap<int, int>::const_iterator it;
@@ -581,10 +581,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_set)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_set<int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.size(), val2.size());
     tr1::unordered_set<int>::const_iterator it;
     for (it = val1.begin(); it != val1.end(); ++it)
@@ -603,10 +603,10 @@ TEST(MSGPACK_TR1, simple_buffer_tr1_unordered_multiset)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     tr1::unordered_multiset<int> val2;
-    obj.convert(val2);
+    obj.convert(&val2);
 
     vector<int> v1, v2;
     tr1::unordered_multiset<int>::const_iterator it;
@@ -760,12 +760,12 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestClass val2;
     val2.i = -1;
     val2.s = "";
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
   }
@@ -793,13 +793,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_old_to_new)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestClass2 val2;
     val2.i = -1;
     val2.s = "";
     val2.v = vector<int>();
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
     EXPECT_FALSE(val2.s.empty());
@@ -815,12 +815,12 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_class_new_to_old)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestClass val2;
     val2.i = -1;
     val2.s = "";
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.i, val2.i);
     EXPECT_EQ(val1.s, val2.s);
     EXPECT_FALSE(val2.s.empty());
@@ -856,13 +856,13 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_enum_member)
   msgpack::zone z;
   msgpack::object obj;
   msgpack::unpack_return ret =
-    msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+    msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
   EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
   TestEnumMemberClass val2;
   val2.t1 = TestEnumMemberClass::STATE_INVALID;
   val2.t2 = TestEnumMemberClass::STATE_INVALID;
   val2.t3 = TestEnumMemberClass::STATE_INVALID;
-  obj.convert(val2);
+  obj.convert(&val2);
   EXPECT_EQ(val1.t1, val2.t1);
   EXPECT_EQ(val1.t2, val2.t2);
   EXPECT_EQ(val1.t3, val2.t3);
@@ -899,13 +899,13 @@ public:
   void msgpack_unpack(msgpack::object o)
   {
     msgpack::type::tuple<bool, msgpack::object> tuple;
-    o.convert(tuple);
+    o.convert(&tuple);
 
-    is_double = msgpack::type::get<0>(tuple);
+    is_double = tuple.get<0>();
     if (is_double)
-      msgpack::type::get<1>(tuple).convert(value.f);
+      tuple.get<1>().convert(&value.f);
     else
-      msgpack::type::get<1>(tuple).convert(value.i);
+      tuple.get<1>().convert(&value.i);
   }
 };
 
@@ -919,10 +919,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestUnionMemberClass val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.is_double, val2.is_double);
     EXPECT_TRUE(fabs(val1.value.f - val2.value.f) < kEPS);
   }
@@ -934,10 +934,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
     msgpack::zone z;
     msgpack::object obj;
     msgpack::unpack_return ret =
-      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+      msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
     EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);
     TestUnionMemberClass val2;
-    obj.convert(val2);
+    obj.convert(&val2);
     EXPECT_EQ(val1.is_double, val2.is_double);
     EXPECT_EQ(val1.value.i, 1);
     EXPECT_EQ(val1.value.i, val2.value.i);
@@ -962,10 +962,10 @@ TEST(MSGPACK_USER_DEFINED, simple_buffer_union_member)
       msgpack::zone z;                                                  \
       msgpack::object obj;                                              \
       msgpack::unpack_return ret =                                      \
-        msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);        \
+        msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);      \
       EXPECT_EQ(msgpack::UNPACK_SUCCESS, ret);                          \
       test_type val2;                                                   \
-      obj.convert(val2);                                               \
+      obj.convert(&val2);                                               \
       EXPECT_EQ(val1, val2);                                            \
     }                                                                   \
   } while(0);
@@ -1094,7 +1094,7 @@ TEST(MSGPACK, vrefbuffer_int64)
         EXPECT_TRUE(life != NULL);                                      \
         pac.reset();                                                    \
         vec_type::value_type val;                                       \
-        obj.convert(val);                                              \
+        obj.convert(&val);                                              \
         EXPECT_EQ(*it, val);                                            \
         ++it;                                                           \
         msgpack::zone::destroy(life);                                   \
diff --git a/test/object.cc b/test/object.cc
index 8916538c..5390c4ae 100644
--- a/test/object.cc
+++ b/test/object.cc
@@ -37,11 +37,11 @@ TEST(object, convert)
 	msgpack::object obj;
 
 	msgpack::unpack_return ret =
-		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
 	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
 
 	myclass m2;
-	obj.convert(m2);
+	obj.convert(&m2);
 
 	EXPECT_EQ(m1, m2);
 }
@@ -58,7 +58,7 @@ TEST(object, as)
 	msgpack::object obj;
 
 	msgpack::unpack_return ret =
-		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
 	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
 
 	EXPECT_EQ(m1, obj.as<myclass>());
diff --git a/test/pack_unpack.cc b/test/pack_unpack.cc
index fd42bc4d..ac47f2d9 100644
--- a/test/pack_unpack.cc
+++ b/test/pack_unpack.cc
@@ -60,7 +60,7 @@ TEST(unpack, myclass)
 	msgpack::object obj;
 
 	msgpack::unpack_return ret =
-		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, z, obj);
+		msgpack::unpack(sbuf.data(), sbuf.size(), NULL, &z, &obj);
 
 	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
 
@@ -81,13 +81,13 @@ TEST(unpack, sequence)
 
 	msgpack::unpacked msg;
 
-	msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset);
+	msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
 	EXPECT_EQ(1, msg.get().as<int>());
 
-	msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset);
+	msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
 	EXPECT_EQ(2, msg.get().as<int>());
 
-	msgpack::unpack(msg, sbuf.data(), sbuf.size(), &offset);
+	msgpack::unpack(&msg, sbuf.data(), sbuf.size(), &offset);
 	EXPECT_EQ(3, msg.get().as<int>());
 }
 
@@ -105,17 +105,17 @@ TEST(unpack, sequence_compat)
 	msgpack::object obj;
 	msgpack::unpack_return ret;
 
-	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj);
+	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
 	EXPECT_TRUE(ret >= 0);
 	EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
 	EXPECT_EQ(1, obj.as<int>());
 
-	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj);
+	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
 	EXPECT_TRUE(ret >= 0);
 	EXPECT_EQ(ret, msgpack::UNPACK_EXTRA_BYTES);
 	EXPECT_EQ(2, obj.as<int>());
 
-	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, z, obj);
+	ret = msgpack::unpack(sbuf.data(), sbuf.size(), &offset, &z, &obj);
 	EXPECT_TRUE(ret >= 0);
 	EXPECT_EQ(ret, msgpack::UNPACK_SUCCESS);
 	EXPECT_EQ(3, obj.as<int>());