diff --git a/src/c_wrapper/clhelper.h b/src/c_wrapper/clhelper.h
index 11c3c9d7ad3540379fb37476adb3d76892342ab7..5285be8d3a562cabcc4310efed4cc0e7f5f784b2 100644
--- a/src/c_wrapper/clhelper.h
+++ b/src/c_wrapper/clhelper.h
@@ -70,7 +70,7 @@ get_opaque_info(cl_int (*func)(ArgTypes...), const char *name,
 {
     typename CLObj::cl_type param_value;
     call_guarded(func, name, args..., sizeof(param_value),
-                 &param_value, nullptr);
+                 out_arg(&param_value), nullptr);
     generic_info info;
     info.dontfree = 0;
     info.opaque_class = CLObj::class_id;
@@ -94,8 +94,7 @@ get_str_info(cl_int (*func)(ArgTypes...), const char *name,
     size_t param_value_size;
     call_guarded(func, name, args..., 0, nullptr, &param_value_size);
     pyopencl_buf<char> param_value(param_value_size);
-    call_guarded(func, name, args..., param_value_size,
-                 param_value.get(), &param_value_size);
+    call_guarded(func, name, args..., param_value, &param_value_size);
     generic_info info;
     info.dontfree = 0;
     info.opaque_class = CLASS_NONE;
@@ -112,7 +111,8 @@ get_int_info(cl_int (*func)(ArgTypes...), const char *name,
              const char *tpname, ArgTypes2&&... args)
 {
     pyopencl_buf<T> param_value;
-    call_guarded(func, name, args..., sizeof(T), param_value.get(), nullptr);
+    call_guarded(func, name, args..., sizeof(T),
+                 out_arg(param_value.get()), nullptr);
     generic_info info;
     info.dontfree = 0;
     info.opaque_class = CLASS_NONE;
@@ -158,13 +158,13 @@ class _CLObjOutArg : public OutArg {
 public:
     PYOPENCL_INLINE
     _CLObjOutArg(clobj_t *ret, cl_int (*release)(CLType),
-                 const char *name, T... t1)
+                 const char *name, T... t1) noexcept
         : m_ret(ret), m_clobj(nullptr), m_release(release),
           m_name(name), m_t1(t1...)
     {
     }
     PYOPENCL_INLINE
-    _CLObjOutArg(_CLObjOutArg<CLObj, T...> &&other)
+    _CLObjOutArg(_CLObjOutArg<CLObj, T...> &&other) noexcept
         : m_ret(other.m_ret), m_clobj(other.m_clobj),
           m_release(other.m_release), m_name(other.m_name)
     {
@@ -176,14 +176,14 @@ public:
         return &m_clobj;
     }
     PYOPENCL_INLINE void
-    finish()
+    convert()
     {
         *m_ret = __new_obj(typename gens<sizeof...(T)>::type());
     }
     PYOPENCL_INLINE void
-    cleanup(bool finished)
+    cleanup(bool converted)
     {
-        if (finished) {
+        if (converted) {
             delete *m_ret;
             *m_ret = nullptr;
         } else {
@@ -197,7 +197,7 @@ public:
         if (!out) {
             stm << &m_clobj;
         } else {
-            stm << CLObj::class_name << "(" << *m_ret << ")<" << m_clobj << ">";
+            stm << "*(" << &m_clobj << "): " << m_clobj;
         }
     }
 };
diff --git a/src/c_wrapper/error.h b/src/c_wrapper/error.h
index 19c5b62c77dab0473154dcb83ea491b88b6ad5ef..f59c1e13fe12ec3185f65a9e9a692bbb0e873413 100644
--- a/src/c_wrapper/error.h
+++ b/src/c_wrapper/error.h
@@ -66,22 +66,22 @@ struct __CLArgGetter {
 template<typename T, class = void>
 struct __CLFinish {
     static PYOPENCL_INLINE void
-    call(T)
+    call(T, bool)
     {
     }
 };
 
 template<typename T>
-struct __CLFinish<T, decltype((void)(std::declval<T>().finish()))> {
+struct __CLFinish<T, decltype((void)(std::declval<T>().finish(true)))> {
     static PYOPENCL_INLINE void
-    call(T v)
+    call(T v, bool converted)
     {
-        v.finish();
+        v.finish(converted);
     }
 };
 
 template<typename T, class = void>
-struct __CLCleanup {
+struct __CLPost {
     static PYOPENCL_INLINE void
     call(T)
     {
@@ -89,11 +89,11 @@ struct __CLCleanup {
 };
 
 template<typename T>
-struct __CLCleanup<T, decltype((void)(std::declval<T>().cleanup()))> {
+struct __CLPost<T, decltype((void)(std::declval<T>().post()))> {
     static PYOPENCL_INLINE void
     call(T v)
     {
-        v.cleanup();
+        v.post();
     }
 };
 
@@ -106,7 +106,8 @@ struct __CLPrintOut {
 };
 
 template<typename T>
-struct __CLPrintOut<T, typename std::enable_if<T::is_out>::type> {
+struct __CLPrintOut<T, typename std::enable_if<
+                           std::remove_reference<T>::type::is_out>::type> {
     static PYOPENCL_INLINE void
     call(T v, std::ostream &stm)
     {
@@ -159,20 +160,28 @@ public:
         -> decltype(this->template call<__CLArgGetter>(func))
     {
         typename CLArgPack::tuple_base *that = this;
+        auto res = this->template call<__CLArgGetter>(func);
         if (DEBUG_ON) {
             std::cerr << name << "(";
             __CLCall<__CLPrint, sizeof...(Types) - 1,
                      decltype(*that)>::call(*that, std::cerr);
-            std::cerr << name << ") = ";
-            // TODO print results
-            std::cerr << std::endl;
+            std::cerr << ") = (" << res << ", ";
+            __CLCall<__CLPrintOut, sizeof...(Types) - 1,
+                     decltype(*that)>::call(*that, std::cerr);
+            std::cerr << ")" << std::endl;
         }
-        auto res = this->template call<__CLArgGetter>(func);
+        return res;
+    }
+    PYOPENCL_INLINE void
+    finish()
+    {
+        typename CLArgPack::tuple_base *that = this;
         __CLCall<__CLFinish, sizeof...(Types) - 1,
+                 decltype(*that)>::call(*that, false);
+        __CLCall<__CLPost, sizeof...(Types) - 1,
                  decltype(*that)>::call(*that);
-        __CLCall<__CLCleanup, sizeof...(Types) - 1,
-                 decltype(*that)>::call(*that);
-        return res;
+        __CLCall<__CLFinish, sizeof...(Types) - 1,
+                 decltype(*that)>::call(*that, true);
     }
 };
 
@@ -193,6 +202,7 @@ call_guarded(cl_int (*func)(ArgTypes...), const char *name, ArgTypes2&&... args)
     if (status_code != CL_SUCCESS) {
         throw clerror(name, status_code);
     }
+    argpack.finish();
 }
 
 template<typename T, typename... ArgTypes, typename... ArgTypes2>
@@ -208,6 +218,7 @@ call_guarded(T (*func)(ArgTypes...), const char *name, ArgTypes2&&... args)
     if (status_code != CL_SUCCESS) {
         throw clerror(name, status_code);
     }
+    argpack.finish();
     return res;
 }
 #define pyopencl_call_guarded(func, args...)    \
@@ -225,6 +236,8 @@ call_guarded_cleanup(cl_int (*func)(ArgTypes...), const char *name,
             << ("PyOpenCL WARNING: a clean-up operation failed "
                 "(dead context maybe?)") << std::endl
             << name << " failed with code " << status_code << std::endl;
+    } else {
+        argpack.finish();
     }
 }
 #define pyopencl_call_guarded_cleanup(func, args...)    \
diff --git a/src/c_wrapper/utils.h b/src/c_wrapper/utils.h
index 5979a3aef392a8c5ca4f0201f8014ee55aaee98d..bc4ecc447797fdf52f8a4b3e7cb6898d7908da58 100644
--- a/src/c_wrapper/utils.h
+++ b/src/c_wrapper/utils.h
@@ -253,26 +253,65 @@ public:
     }
 };
 
-class OutArg {
+struct OutArg {
+    PYOPENCL_INLINE void
+    convert()
+    {}
+    PYOPENCL_INLINE void
+    cleanup(bool)
+    {}
+};
+
+template<typename T>
+class _SimpleOutArg : public OutArg {
+    T *m_t;
+public:
+    _SimpleOutArg(T *t)
+        : m_t(t)
+    {}
+    PYOPENCL_INLINE T*
+    get()
+    {
+        return m_t;
+    }
+    template<bool out>
+    PYOPENCL_INLINE void
+    print(std::ostream &stm)
+    {
+        if (!out) {
+            stm << m_t;
+        } else {
+            stm << "*(" << m_t << "): " << *m_t;
+        }
+    }
 };
 
+template<typename T>
+static PYOPENCL_INLINE _SimpleOutArg<T>
+out_arg(T *t)
+{
+    return _SimpleOutArg<T>(t);
+}
+
 template<typename T>
 class CLArg<T, typename std::enable_if<
                       std::is_base_of<OutArg, T>::value>::type> {
 private:
-    bool m_finished;
+    bool m_converted;
     bool m_need_cleanup;
     T &m_arg;
 public:
     constexpr static bool is_out = true;
     CLArg(T &arg)
-        : m_finished(false), m_need_cleanup(true), m_arg(arg)
+        : m_converted(false), m_need_cleanup(false), m_arg(arg)
     {
     }
     CLArg(CLArg<T> &&other) noexcept
-        : m_finished(other.m_finished), m_need_cleanup(other.m_need_cleanup),
+        : m_converted(other.m_converted), m_need_cleanup(other.m_need_cleanup),
         m_arg(other.m_arg)
-    {}
+    {
+        other.m_need_cleanup = false;
+    }
     PYOPENCL_INLINE auto
     convert()
         -> decltype(m_arg.get())
@@ -280,20 +319,20 @@ public:
         return m_arg.get();
     }
     PYOPENCL_INLINE void
-    finish()
+    finish(bool converted) noexcept
     {
-        m_arg.finish();
-        m_finished = true;
+        m_need_cleanup = !converted;
     }
     PYOPENCL_INLINE void
-    cleanup()
+    post()
     {
-        m_need_cleanup = false;
+        m_arg.convert();
+        m_converted = true;
     }
     ~CLArg()
     {
         if (m_need_cleanup) {
-            m_arg.cleanup(m_finished);
+            m_arg.cleanup(m_converted);
         }
     }
     template<bool out>