@@ -384,7 +384,8 @@ inline PyObject *read_pair_array(ReaderT *reader, TypeTreeNodeObject *node, Type
             Py_DECREF(list);
             return NULL;
         }
-        PyList_SET_ITEM(list, i, PyTuple_Pack(2, first, second));
+        PyList_SET_ITEM(list, i, PyTuple_Pack(2, first, second)); // pack creates two strong references
+        // so we need to decref both values here to bring their ref count back to 1
         Py_DECREF(first);
         Py_DECREF(second);
     }
@@ -396,10 +397,10 @@ template <bool swap, bool as_dict>
 inline PyObject *read_class(ReaderT *reader, TypeTreeNodeObject *node, TypeTreeReaderConfigT *config)
 {
     bool changed_registry = false;
-    PyObject *value = PyDict_New();
+    PyObject *value = PyDict_New(); // value: 1 refcount
     for (int i = 0; i < PyList_GET_SIZE(node->m_Children); i++)
     {
-        TypeTreeNodeObject *child = (TypeTreeNodeObject *)PyList_GET_ITEM(node->m_Children, i);
+        TypeTreeNodeObject *child = (TypeTreeNodeObject *)PyList_GET_ITEM(node->m_Children, i); // no refcount change
         if (child->_data_type == NodeDataType::ManagedReferencesRegistry)
         {
             if (config->has_registry)
@@ -412,29 +413,29 @@ inline PyObject *read_class(ReaderT *reader, TypeTreeNodeObject *node, TypeTreeR
                 config->has_registry = true;
             }
         }
-        PyObject *child_value = read_typetree_value<swap>(reader, child, config);
+        PyObject *child_value = read_typetree_value<swap>(reader, child, config); // child_value: 1 refcount
         if (!child_value)
         {
-            Py_DECREF(value);
+            Py_DECREF(value); // value: 0 refcount
             return NULL;
         }
         int set_item_result;
         if constexpr (as_dict == true)
         {
-            set_item_result = PyDict_SetItem(value, child->m_Name, child_value);
+            set_item_result = PyDict_SetItem(value, child->m_Name, child_value); // child_value: 2 refcount
         }
         else
         {
-            set_item_result = PyDict_SetItem(value, child->_clean_name, child_value);
+            set_item_result = PyDict_SetItem(value, child->_clean_name, child_value); // child_value: 2 refcount
         }
         if (set_item_result != 0)
         {
-            Py_DECREF(value);
-            Py_DECREF(child_value);
+            Py_DECREF(value);       // value: 0 refcount
+            Py_DECREF(child_value); // child_value: 0 refcount
             return NULL;
         }
         // PyDict_SetItem increases ref count, so we need to decref here
-        Py_DECREF(child_value);
+        Py_DECREF(child_value); // child_value: 1 refcount
     }
 
     if (changed_registry)
@@ -1033,6 +1034,7 @@ static void TypeTreeNode_dealloc(TypeTreeNodeObject *self)
     Py_XDECREF(self->m_MetaFlag);
     Py_XDECREF(self->m_RefTypeHash);
     Py_XDECREF(self->m_Children);
+    Py_XDECREF(self->_clean_name);
     Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
@@ -1129,6 +1131,7 @@ static int TypeTreeNode_init(TypeTreeNodeObject *self, PyObject *args, PyObject
     self->m_Index = nullptr;
     self->m_MetaFlag = nullptr;
     self->m_RefTypeHash = nullptr;
+    self->_clean_name = nullptr;
 
     if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O!O!O!O!|O!O!O!O!O!O!", (char **)kwlist,
                                      // required fields
@@ -1176,7 +1179,7 @@ static int TypeTreeNode_init(TypeTreeNodeObject *self, PyObject *args, PyObject
 
     std::string sname = PyUnicode_AsUTF8(self->m_Name);
     std::string sclean_name = clean_name(sname);
-    self->_clean_name = PyUnicode_FromString(sclean_name.c_str());
+    self->_clean_name = PyUnicode_FromString(sclean_name.c_str()); // comes with strong ref
     return 0;
 }
Original file line number	Diff line number	Diff line change
`@@ -384,7 +384,8 @@ inline PyObject read_pair_array(ReaderT reader, TypeTreeNodeObject *node, Type`
`384`	`384`	`Py_DECREF(list);`
`385`	`385`	`return NULL;`
`386`	`386`	`}`
`387`		`- PyList_SET_ITEM(list, i, PyTuple_Pack(2, first, second));`
	`387`	`+ PyList_SET_ITEM(list, i, PyTuple_Pack(2, first, second)); // pack creates two strong references`
	`388`	`+ // so we need to decref both values here to bring their ref count back to 1`
`388`	`389`	`Py_DECREF(first);`
`389`	`390`	`Py_DECREF(second);`
`390`	`391`	`}`
`@@ -396,10 +397,10 @@ template <bool swap, bool as_dict>`
`396`	`397`	`inline PyObject read_class(ReaderT reader, TypeTreeNodeObject node, TypeTreeReaderConfigT config)`
`397`	`398`	`{`
`398`	`399`	`bool changed_registry = false;`
`399`		`- PyObject *value = PyDict_New();`
	`400`	`+ PyObject *value = PyDict_New(); // value: 1 refcount`
`400`	`401`	`for (int i = 0; i < PyList_GET_SIZE(node->m_Children); i++)`
`401`	`402`	`{`
`402`		`- TypeTreeNodeObject child = (TypeTreeNodeObject )PyList_GET_ITEM(node->m_Children, i);`
	`403`	`+ TypeTreeNodeObject child = (TypeTreeNodeObject )PyList_GET_ITEM(node->m_Children, i); // no refcount change`
`403`	`404`	`if (child->_data_type == NodeDataType::ManagedReferencesRegistry)`
`404`	`405`	`{`
`405`	`406`	`if (config->has_registry)`
`@@ -412,29 +413,29 @@ inline PyObject read_class(ReaderT reader, TypeTreeNodeObject *node, TypeTreeR`
`412`	`413`	`config->has_registry = true;`
`413`	`414`	`}`
`414`	`415`	`}`
`415`		`- PyObject *child_value = read_typetree_value<swap>(reader, child, config);`
	`416`	`+ PyObject *child_value = read_typetree_value<swap>(reader, child, config); // child_value: 1 refcount`
`416`	`417`	`if (!child_value)`
`417`	`418`	`{`
`418`		`- Py_DECREF(value);`
	`419`	`+ Py_DECREF(value); // value: 0 refcount`
`419`	`420`	`return NULL;`
`420`	`421`	`}`
`421`	`422`	`int set_item_result;`
`422`	`423`	`if constexpr (as_dict == true)`
`423`	`424`	`{`
`424`		`- set_item_result = PyDict_SetItem(value, child->m_Name, child_value);`
	`425`	`+ set_item_result = PyDict_SetItem(value, child->m_Name, child_value); // child_value: 2 refcount`
`425`	`426`	`}`
`426`	`427`	`else`
`427`	`428`	`{`
`428`		`- set_item_result = PyDict_SetItem(value, child->_clean_name, child_value);`
	`429`	`+ set_item_result = PyDict_SetItem(value, child->_clean_name, child_value); // child_value: 2 refcount`
`429`	`430`	`}`
`430`	`431`	`if (set_item_result != 0)`
`431`	`432`	`{`
`432`		`- Py_DECREF(value);`
`433`		`- Py_DECREF(child_value);`
	`433`	`+ Py_DECREF(value); // value: 0 refcount`
	`434`	`+ Py_DECREF(child_value); // child_value: 0 refcount`
`434`	`435`	`return NULL;`
`435`	`436`	`}`
`436`	`437`	`// PyDict_SetItem increases ref count, so we need to decref here`
`437`		`- Py_DECREF(child_value);`
	`438`	`+ Py_DECREF(child_value); // child_value: 1 refcount`
`438`	`439`	`}`
`439`	`440`
`440`	`441`	`if (changed_registry)`
`@@ -1033,6 +1034,7 @@ static void TypeTreeNode_dealloc(TypeTreeNodeObject *self)`
`1033`	`1034`	`Py_XDECREF(self->m_MetaFlag);`
`1034`	`1035`	`Py_XDECREF(self->m_RefTypeHash);`
`1035`	`1036`	`Py_XDECREF(self->m_Children);`
	`1037`	`+ Py_XDECREF(self->_clean_name);`
`1036`	`1038`	`Py_TYPE(self)->tp_free((PyObject *)self);`
`1037`	`1039`	`}`
`1038`	`1040`
`@@ -1129,6 +1131,7 @@ static int TypeTreeNode_init(TypeTreeNodeObject self, PyObject args, PyObject`
`1129`	`1131`	`self->m_Index = nullptr;`
`1130`	`1132`	`self->m_MetaFlag = nullptr;`
`1131`	`1133`	`self->m_RefTypeHash = nullptr;`
	`1134`	`+ self->_clean_name = nullptr;`
`1132`	`1135`
`1133`	`1136`	`if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O!O!O!O!\|O!O!O!O!O!O!", (char **)kwlist,`
`1134`	`1137`	`// required fields`
`@@ -1176,7 +1179,7 @@ static int TypeTreeNode_init(TypeTreeNodeObject self, PyObject args, PyObject`
`1176`	`1179`
`1177`	`1180`	`std::string sname = PyUnicode_AsUTF8(self->m_Name);`
`1178`	`1181`	`std::string sclean_name = clean_name(sname);`
`1179`		`- self->_clean_name = PyUnicode_FromString(sclean_name.c_str());`
	`1182`	`+ self->_clean_name = PyUnicode_FromString(sclean_name.c_str()); // comes with strong ref`
`1180`	`1183`	`return 0;`
`1181`	`1184`	`}`
`1182`	`1185`