@@ -76,7 +76,7 @@ inline PyObject *read_bool(ReaderT *reader)
     if (reader->ptr + 1 > reader->end)
     {
         PyErr_SetString(PyExc_ValueError, "read_bool out of bounds");
-        return NULL;
+        return nullptr;
     }
     PyObject *value = *reader->ptr++ ? Py_True : Py_False;
     Py_INCREF(value);
@@ -88,7 +88,7 @@ inline PyObject *read_bool_array(ReaderT *reader, int32_t count)
     if (reader->ptr + count > reader->end)
     {
         PyErr_SetString(PyExc_ValueError, "read_bool_array out of bounds");
-        return NULL;
+        return nullptr;
     }
     PyObject *list = PyList_New(count);
     for (auto i = 0; i < count; i++)
@@ -105,7 +105,7 @@ inline PyObject *read_u8(ReaderT *reader)
     if (reader->ptr + 1 > reader->end)
     {
         PyErr_SetString(PyExc_ValueError, "read_u8 out of bounds");
-        return NULL;
+        return nullptr;
     }
     return PyLong_FromUnsignedLong(*reader->ptr++);
 }
@@ -115,7 +115,7 @@ inline PyObject *read_u8_array(ReaderT *reader, int32_t count)
     if (reader->ptr + count > reader->end)
     {
         PyErr_SetString(PyExc_ValueError, "read_u8_array out of bounds");
-        return NULL;
+        return nullptr;
     }
     PyObject *list = PyList_New(count);
     for (auto i = 0; i < count; i++)
@@ -130,7 +130,7 @@ inline PyObject *read_s8(ReaderT *reader)
     if (reader->ptr + 1 > reader->end)
     {
         PyErr_SetString(PyExc_ValueError, "read_s8 out of bounds");
-        return NULL;
+        return nullptr;
     }
     return PyLong_FromLong((int8_t)*reader->ptr++);
 }
@@ -140,7 +140,7 @@ inline PyObject *read_s8_array(ReaderT *reader, int32_t count)
     if (reader->ptr + count > reader->end)
     {
         PyErr_SetString(PyExc_ValueError, "read_s8_array out of bounds");
-        return NULL;
+        return nullptr;
     }
     PyObject *list = PyList_New(count);
     int8_t *ptr = (int8_t *)reader->ptr;
@@ -291,12 +291,12 @@ inline PyObject *read_str(ReaderT *reader)
     int32_t length;
     if (!_read_length<swap>(reader, &length))
     {
-        return NULL;
+        return nullptr;
     }
     if (reader->ptr + length > reader->end)
     {
         PyErr_SetString(PyExc_EOFError, "read_str out of bounds");
-        return NULL;
+        return nullptr;
     }
     PyObject *py_str = PyUnicode_DecodeUTF8((char *)reader->ptr, length, "surrogateescape");
     reader->ptr += length;
@@ -310,12 +310,12 @@ inline PyObject *read_bytes(ReaderT *reader)
     int32_t length;
     if (!_read_length<swap>(reader, &length))
     {
-        return NULL;
+        return nullptr;
     }
     if (reader->ptr + length > reader->end)
     {
         PyErr_SetString(PyExc_ValueError, "read_bytes out of bounds");
-        return NULL;
+        return nullptr;
     }
     PyObject *bytes = PyBytes_FromStringAndSize((char *)reader->ptr, length);
     reader->ptr += length;
@@ -328,19 +328,19 @@ inline PyObject *read_pair(ReaderT *reader, TypeTreeNodeObject *node, TypeTreeRe
     if (PyList_GET_SIZE(node->m_Children) != 2)
     {
         PyErr_SetString(PyExc_ValueError, "Pair node must have 2 children");
-        return NULL;
+        return nullptr;
     }
 
     PyObject *first = read_typetree_value<swap>(reader, (TypeTreeNodeObject *)PyList_GET_ITEM(node->m_Children, 0), config);
-    if (first == NULL)
+    if (first == nullptr)
     {
-        return NULL;
+        return nullptr;
     }
     PyObject *second = read_typetree_value<swap>(reader, (TypeTreeNodeObject *)PyList_GET_ITEM(node->m_Children, 1), config);
-    if (second == NULL)
+    if (second == nullptr)
     {
         Py_DECREF(first);
-        return NULL;
+        return nullptr;
     }
     // PyTuple_Pack creates two strong references
     PyObject *pair = PyTuple_Pack(2, first, second);
@@ -356,31 +356,31 @@ inline PyObject *read_pair_array(ReaderT *reader, TypeTreeNodeObject *node, Type
     if (PyList_GET_SIZE(node->m_Children) != 2)
     {
         PyErr_SetString(PyExc_ValueError, "Pair node must have 2 children");
-        return NULL;
+        return nullptr;
     }
 
     TypeTreeNodeObject *first_child = (TypeTreeNodeObject *)PyList_GET_ITEM(node->m_Children, 0);
     TypeTreeNodeObject *second_child = (TypeTreeNodeObject *)PyList_GET_ITEM(node->m_Children, 1);
 
     PyObject *list = PyList_New(count);
-    if (list == NULL)
+    if (list == nullptr)
     {
-        return NULL;
+        return nullptr;
     }
     for (auto i = 0; i < count; i++)
     {
         PyObject *first = read_typetree_value<swap>(reader, first_child, config);
-        if (first == NULL)
+        if (first == nullptr)
         {
             Py_DECREF(list);
-            return NULL;
+            return nullptr;
         }
         PyObject *second = read_typetree_value<swap>(reader, second_child, config);
-        if (second == NULL)
+        if (second == nullptr)
         {
             Py_DECREF(first);
             Py_DECREF(list);
-            return NULL;
+            return nullptr;
         }
         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
@@ -412,10 +412,10 @@ inline PyObject *read_class(ReaderT *reader, TypeTreeNodeObject *node, TypeTreeR
             }
         }
         PyObject *child_value = read_typetree_value<swap>(reader, child, config); // child_value: 1 refcount
-        if (child_value == NULL)
+        if (child_value == nullptr)
         {
             Py_DECREF(value); // value: 0 refcount
-            return NULL;
+            return nullptr;
         }
         int set_item_result;
         if constexpr (as_dict == true)
@@ -430,7 +430,7 @@ inline PyObject *read_class(ReaderT *reader, TypeTreeNodeObject *node, TypeTreeR
         {
             Py_DECREF(value);       // value: 0 refcount
             Py_DECREF(child_value); // child_value: 0 refcount
-            return NULL;
+            return nullptr;
         }
         // PyDict_SetItem increases ref count, so we need to decref here
         Py_DECREF(child_value); // child_value: 1 refcount
@@ -449,7 +449,7 @@ static PyObject *_get_annotations = nullptr;
 inline PyObject *get_annotations(PyObject *clz)
 {
 #if PY_VERSION_HEX >= 0x030e0000
-    return PyObject_CallFunctionObjArgs(_get_annotations, clz, NULL);
+    return PyObject_CallFunctionObjArgs(_get_annotations, clz, nullptr);
 #else
     return PyObject_GetAttrString(clz, "__annotations__");
 #endif
@@ -468,9 +468,9 @@ inline PyObject *parse_class(PyObject *kwargs, TypeTreeNodeObject *node, TypeTre
     // slots check
     PyObject *slots = nullptr;
 
-    if (kwargs == NULL)
+    if (kwargs == nullptr)
     {
-        return NULL;
+        return nullptr;
     }
 
     if (node->_data_type == NodeDataType::PPtr)
@@ -587,27 +587,27 @@ TypeTreeNodeObject *get_ref_type_node(PyObject *ref_object, PyObject *assetsfile
     if (assetsfile == Py_None)
     {
         PyErr_SetString(PyExc_ValueError, "Reference Type found but no SerializedFile passed as assetsfile to read_typetree!");
-        return NULL;
+        return nullptr;
     }
     PyObject *ref_types = PyObject_GetAttrString(assetsfile, "ref_types");
     if (!ref_types || !PyList_Check(ref_types))
     {
         Py_XDECREF(ref_types);
         PyErr_SetString(PyExc_ValueError, "No SerializedFile.ref_types");
-        return NULL;
+        return nullptr;
     }
 
     PyObject *type = PyDict_GetItemString(ref_object, "type");
     if (!type)
     {
         Py_DECREF(ref_types);
         PyErr_SetString(PyExc_ValueError, "Failed to get 'type'");
-        return NULL;
+        return nullptr;
     }
 
-    PyObject *cls = NULL;
-    PyObject *ns = NULL;
-    PyObject *asm_ = NULL;
+    PyObject *cls = nullptr;
+    PyObject *ns = nullptr;
+    PyObject *asm_ = nullptr;
     if (PyDict_Check(type))
     {
         cls = PyDict_GetItemString(type, "class");
@@ -631,7 +631,7 @@ TypeTreeNodeObject *get_ref_type_node(PyObject *ref_object, PyObject *assetsfile
         Py_XDECREF(ns);
         Py_XDECREF(asm_);
         PyErr_SetString(PyExc_ValueError, "Failed to get 'class', 'ns' or 'asm'");
-        return NULL;
+        return nullptr;
     }
 
     if (PyUnicode_GET_LENGTH(cls) == 0)
@@ -644,7 +644,7 @@ TypeTreeNodeObject *get_ref_type_node(PyObject *ref_object, PyObject *assetsfile
     }
 
     Py_ssize_t ref_types_len = PyList_Size(ref_types);
-    TypeTreeNodeObject *ref_type_node = NULL;
+    TypeTreeNodeObject *ref_type_node = nullptr;
     for (Py_ssize_t i = 0; i < ref_types_len; i++)
     {
         PyObject *ref_type = PyList_GetItem(ref_types, i);
@@ -762,7 +762,7 @@ PyObject *read_typetree_value(ReaderT *reader, TypeTreeNodeObject *node, TypeTre
                 {
                     PyErr_SetString(PyExc_ValueError, "Failed to get ref type node");
                     Py_DECREF(value);
-                    return NULL;
+                    return nullptr;
                 }
                 else if (ref_node == (TypeTreeNodeObject *)Py_None)
                 {
@@ -777,28 +777,28 @@ PyObject *read_typetree_value(ReaderT *reader, TypeTreeNodeObject *node, TypeTre
                 child_value = read_typetree_value<swap>(reader, child, config);
             }
 
-            if (child_value == NULL)
+            if (child_value == nullptr)
             {
                 Py_DECREF(value);
-                return NULL;
+                return nullptr;
             }
             if (PyDict_SetItem(value, child->m_Name, child_value))
             {
                 Py_DECREF(value);
                 Py_DECREF(child_value);
-                return NULL;
+                return nullptr;
             }
             // dict increases ref count, so we need to decref here
             Py_DECREF(child_value);
         }
         if (!config->as_dict)
         {
             PyObject *clz = PyObject_GetAttrString(config->classes, "UnknownObject");
-            if (clz == NULL)
+            if (clz == nullptr)
             {
                 PyErr_SetString(PyExc_ValueError, "Failed to get class");
                 Py_DECREF(value);
-                return NULL;
+                return nullptr;
             }
             PyObject *args = PyTuple_Pack(1, (PyObject *)node);
             PyObject *instance = PyObject_Call(clz, args, value);
@@ -822,7 +822,7 @@ PyObject *read_typetree_value(ReaderT *reader, TypeTreeNodeObject *node, TypeTre
             if (PyList_GET_SIZE(child->m_Children) != 2)
             {
                 PyErr_SetString(PyExc_ValueError, "Array node must have 2 children");
-                return NULL;
+                return nullptr;
             }
 
             if (child->_align)
@@ -832,24 +832,24 @@ PyObject *read_typetree_value(ReaderT *reader, TypeTreeNodeObject *node, TypeTre
             int32_t length;
             if (!_read_length<swap>(reader, &length))
             {
-                return NULL;
+                return nullptr;
             }
 
             child = (TypeTreeNodeObject *)PyList_GET_ITEM(child->m_Children, 1);
             if (std::find(std::begin(SUPPORTED_VALUE_ARRAY_READ_TYPES), std::end(SUPPORTED_VALUE_ARRAY_READ_TYPES), child->_data_type) == std::end(SUPPORTED_VALUE_ARRAY_READ_TYPES))
             {
                 value = PyList_New(length);
-                if (value == NULL)
+                if (value == nullptr)
                 {
-                    return NULL;
+                    return nullptr;
                 }
                 for (int i = 0; i < length; i++)
                 {
                     PyObject *item = read_typetree_value<swap>(reader, child, config);
-                    if (item == NULL)
+                    if (item == nullptr)
                     {
                         Py_DECREF(value);
-                        return NULL;
+                        return nullptr;
                     }
                     PyList_SET_ITEM(value, i, item);
                 }
@@ -874,7 +874,7 @@ PyObject *read_typetree_value(ReaderT *reader, TypeTreeNodeObject *node, TypeTre
         }
     }
 
-    if (align && value != NULL)
+    if (align && value != nullptr)
     {
         align4(reader);
     }
@@ -931,7 +931,7 @@ PyObject *read_typetree_value_array(ReaderT *reader, TypeTreeNodeObject *node, T
         PyErr_SetString(PyExc_TypeError, error_msg.c_str());
         value = nullptr;
     }
-    if (align && value != NULL)
+    if (align && value != nullptr)
     {
         align4(reader);
     }
@@ -961,7 +961,7 @@ static bool is_null_none_or_type(PyObject *obj, PyTypeObject *type, const char *
 
 PyObject *read_typetree(PyObject *self, PyObject *args, PyObject *kwargs)
 {
-    const char *kwlist[] = {"data", "node", "endian", "as_dict", "assetsfile", "classes", NULL};
+    const char *kwlist[] = {"data", "node", "endian", "as_dict", "assetsfile", "classes", nullptr};
     Py_buffer view;
     PyObject *node = nullptr;
     int as_dict = 1;
@@ -1027,7 +1027,7 @@ PyObject *read_typetree(PyObject *self, PyObject *args, PyObject *kwargs)
         Py_DECREF(config.assetfile);
         Py_DECREF(config.classes);
         PyErr_SetString(PyExc_ValueError, "Invalid endian");
-        return NULL;
+        return nullptr;
     }
     }
 
@@ -1052,7 +1052,7 @@ PyObject *read_typetree(PyObject *self, PyObject *args, PyObject *kwargs)
     Py_XDECREF(config.assetfile);
     Py_XDECREF(config.classes);
 
-    return (value != NULL) ? Py_BuildValue("(Nn)", value, bytes_read) : NULL;
+    return (value != nullptr) ? Py_BuildValue("(Nn)", value, bytes_read) : nullptr;
 }
 
 // TypeTreeNode impl
@@ -1141,7 +1141,7 @@ static int TypeTreeNode_init(TypeTreeNodeObject *self, PyObject *args, PyObject
         "m_Index",
         "m_MetaFlag",
         "m_RefTypeHash",
-        NULL};
+        nullptr};
 
     // ensure all fields are set to 0
     // in case init fails, so that dealloc doesn't segfault
@@ -1244,16 +1244,16 @@ static PyMemberDef TypeTreeNode_members[] = {
     {"m_MetaFlag", T_OBJECT_EX, offsetof(TypeTreeNodeObject, m_MetaFlag), 0, ""},
     {"m_RefTypeHash", T_OBJECT_EX, offsetof(TypeTreeNodeObject, m_RefTypeHash), 0, ""},
     {"_clean_name", T_OBJECT_EX, offsetof(TypeTreeNodeObject, _clean_name), 0, ""},
-    {NULL} /* Sentinel */
+    {nullptr} /* Sentinel */
 };
 
 static PyTypeObject TypeTreeNodeType = []() -> PyTypeObject
 {
     PyTypeObject type = {
 #if PY_VERSION_HEX >= 0x03080000
-        PyVarObject_HEAD_INIT(NULL, 0)
+        PyVarObject_HEAD_INIT(nullptr, 0)
 #else
-        PyObject_HEAD_INIT(NULL) 0
+        PyObject_HEAD_INIT(nullptr) 0
 #endif
     };
     type.tp_name = "TypeTreeHelper.TypeTreeNode";
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ inline PyObject read_bool(ReaderT reader)`
`76`	`76`	`if (reader->ptr + 1 > reader->end)`
`77`	`77`	`{`
`78`	`78`	`PyErr_SetString(PyExc_ValueError, "read_bool out of bounds");`
`79`		`- return NULL;`
	`79`	`+ return nullptr;`
`80`	`80`	`}`
`81`	`81`	`PyObject value = reader->ptr++ ? Py_True : Py_False;`
`82`	`82`	`Py_INCREF(value);`
`@@ -88,7 +88,7 @@ inline PyObject read_bool_array(ReaderT reader, int32_t count)`
`88`	`88`	`if (reader->ptr + count > reader->end)`
`89`	`89`	`{`
`90`	`90`	`PyErr_SetString(PyExc_ValueError, "read_bool_array out of bounds");`
`91`		`- return NULL;`
	`91`	`+ return nullptr;`
`92`	`92`	`}`
`93`	`93`	`PyObject *list = PyList_New(count);`
`94`	`94`	`for (auto i = 0; i < count; i++)`
`@@ -105,7 +105,7 @@ inline PyObject read_u8(ReaderT reader)`
`105`	`105`	`if (reader->ptr + 1 > reader->end)`
`106`	`106`	`{`
`107`	`107`	`PyErr_SetString(PyExc_ValueError, "read_u8 out of bounds");`
`108`		`- return NULL;`
	`108`	`+ return nullptr;`
`109`	`109`	`}`
`110`	`110`	`return PyLong_FromUnsignedLong(*reader->ptr++);`
`111`	`111`	`}`
`@@ -115,7 +115,7 @@ inline PyObject read_u8_array(ReaderT reader, int32_t count)`
`115`	`115`	`if (reader->ptr + count > reader->end)`
`116`	`116`	`{`
`117`	`117`	`PyErr_SetString(PyExc_ValueError, "read_u8_array out of bounds");`
`118`		`- return NULL;`
	`118`	`+ return nullptr;`
`119`	`119`	`}`
`120`	`120`	`PyObject *list = PyList_New(count);`
`121`	`121`	`for (auto i = 0; i < count; i++)`
`@@ -130,7 +130,7 @@ inline PyObject read_s8(ReaderT reader)`
`130`	`130`	`if (reader->ptr + 1 > reader->end)`
`131`	`131`	`{`
`132`	`132`	`PyErr_SetString(PyExc_ValueError, "read_s8 out of bounds");`
`133`		`- return NULL;`
	`133`	`+ return nullptr;`
`134`	`134`	`}`
`135`	`135`	`return PyLong_FromLong((int8_t)*reader->ptr++);`
`136`	`136`	`}`
`@@ -140,7 +140,7 @@ inline PyObject read_s8_array(ReaderT reader, int32_t count)`
`140`	`140`	`if (reader->ptr + count > reader->end)`
`141`	`141`	`{`
`142`	`142`	`PyErr_SetString(PyExc_ValueError, "read_s8_array out of bounds");`
`143`		`- return NULL;`
	`143`	`+ return nullptr;`
`144`	`144`	`}`
`145`	`145`	`PyObject *list = PyList_New(count);`
`146`	`146`	`int8_t ptr = (int8_t )reader->ptr;`
`@@ -291,12 +291,12 @@ inline PyObject read_str(ReaderT reader)`
`291`	`291`	`int32_t length;`
`292`	`292`	`if (!_read_length<swap>(reader, &length))`
`293`	`293`	`{`
`294`		`- return NULL;`
	`294`	`+ return nullptr;`
`295`	`295`	`}`
`296`	`296`	`if (reader->ptr + length > reader->end)`
`297`	`297`	`{`
`298`	`298`	`PyErr_SetString(PyExc_EOFError, "read_str out of bounds");`
`299`		`- return NULL;`
	`299`	`+ return nullptr;`
`300`	`300`	`}`
`301`	`301`	`PyObject py_str = PyUnicode_DecodeUTF8((char )reader->ptr, length, "surrogateescape");`
`302`	`302`	`reader->ptr += length;`
`@@ -310,12 +310,12 @@ inline PyObject read_bytes(ReaderT reader)`
`310`	`310`	`int32_t length;`
`311`	`311`	`if (!_read_length<swap>(reader, &length))`
`312`	`312`	`{`
`313`		`- return NULL;`
	`313`	`+ return nullptr;`
`314`	`314`	`}`
`315`	`315`	`if (reader->ptr + length > reader->end)`
`316`	`316`	`{`
`317`	`317`	`PyErr_SetString(PyExc_ValueError, "read_bytes out of bounds");`
`318`		`- return NULL;`
	`318`	`+ return nullptr;`
`319`	`319`	`}`
`320`	`320`	`PyObject bytes = PyBytes_FromStringAndSize((char )reader->ptr, length);`
`321`	`321`	`reader->ptr += length;`
`@@ -328,19 +328,19 @@ inline PyObject read_pair(ReaderT reader, TypeTreeNodeObject *node, TypeTreeRe`
`328`	`328`	`if (PyList_GET_SIZE(node->m_Children) != 2)`
`329`	`329`	`{`
`330`	`330`	`PyErr_SetString(PyExc_ValueError, "Pair node must have 2 children");`
`331`		`- return NULL;`
	`331`	`+ return nullptr;`
`332`	`332`	`}`
`333`	`333`
`334`	`334`	`PyObject first = read_typetree_value<swap>(reader, (TypeTreeNodeObject )PyList_GET_ITEM(node->m_Children, 0), config);`
`335`		`- if (first == NULL)`
	`335`	`+ if (first == nullptr)`
`336`	`336`	`{`
`337`		`- return NULL;`
	`337`	`+ return nullptr;`
`338`	`338`	`}`
`339`	`339`	`PyObject second = read_typetree_value<swap>(reader, (TypeTreeNodeObject )PyList_GET_ITEM(node->m_Children, 1), config);`
`340`		`- if (second == NULL)`
	`340`	`+ if (second == nullptr)`
`341`	`341`	`{`
`342`	`342`	`Py_DECREF(first);`
`343`		`- return NULL;`
	`343`	`+ return nullptr;`
`344`	`344`	`}`
`345`	`345`	`// PyTuple_Pack creates two strong references`
`346`	`346`	`PyObject *pair = PyTuple_Pack(2, first, second);`
`@@ -356,31 +356,31 @@ inline PyObject read_pair_array(ReaderT reader, TypeTreeNodeObject *node, Type`
`356`	`356`	`if (PyList_GET_SIZE(node->m_Children) != 2)`
`357`	`357`	`{`
`358`	`358`	`PyErr_SetString(PyExc_ValueError, "Pair node must have 2 children");`
`359`		`- return NULL;`
	`359`	`+ return nullptr;`
`360`	`360`	`}`
`361`	`361`
`362`	`362`	`TypeTreeNodeObject first_child = (TypeTreeNodeObject )PyList_GET_ITEM(node->m_Children, 0);`
`363`	`363`	`TypeTreeNodeObject second_child = (TypeTreeNodeObject )PyList_GET_ITEM(node->m_Children, 1);`
`364`	`364`
`365`	`365`	`PyObject *list = PyList_New(count);`
`366`		`- if (list == NULL)`
	`366`	`+ if (list == nullptr)`
`367`	`367`	`{`
`368`		`- return NULL;`
	`368`	`+ return nullptr;`
`369`	`369`	`}`
`370`	`370`	`for (auto i = 0; i < count; i++)`
`371`	`371`	`{`
`372`	`372`	`PyObject *first = read_typetree_value<swap>(reader, first_child, config);`
`373`		`- if (first == NULL)`
	`373`	`+ if (first == nullptr)`
`374`	`374`	`{`
`375`	`375`	`Py_DECREF(list);`
`376`		`- return NULL;`
	`376`	`+ return nullptr;`
`377`	`377`	`}`
`378`	`378`	`PyObject *second = read_typetree_value<swap>(reader, second_child, config);`
`379`		`- if (second == NULL)`
	`379`	`+ if (second == nullptr)`
`380`	`380`	`{`
`381`	`381`	`Py_DECREF(first);`
`382`	`382`	`Py_DECREF(list);`
`383`		`- return NULL;`
	`383`	`+ return nullptr;`
`384`	`384`	`}`
`385`	`385`	`PyList_SET_ITEM(list, i, PyTuple_Pack(2, first, second)); // pack creates two strong references`
`386`	`386`	`// so we need to decref both values here to bring their ref count back to 1`
`@@ -412,10 +412,10 @@ inline PyObject read_class(ReaderT reader, TypeTreeNodeObject *node, TypeTreeR`
`412`	`412`	`}`
`413`	`413`	`}`
`414`	`414`	`PyObject *child_value = read_typetree_value<swap>(reader, child, config); // child_value: 1 refcount`
`415`		`- if (child_value == NULL)`
	`415`	`+ if (child_value == nullptr)`
`416`	`416`	`{`
`417`	`417`	`Py_DECREF(value); // value: 0 refcount`
`418`		`- return NULL;`
	`418`	`+ return nullptr;`
`419`	`419`	`}`
`420`	`420`	`int set_item_result;`
`421`	`421`	`if constexpr (as_dict == true)`
`@@ -430,7 +430,7 @@ inline PyObject read_class(ReaderT reader, TypeTreeNodeObject *node, TypeTreeR`
`430`	`430`	`{`
`431`	`431`	`Py_DECREF(value); // value: 0 refcount`
`432`	`432`	`Py_DECREF(child_value); // child_value: 0 refcount`
`433`		`- return NULL;`
	`433`	`+ return nullptr;`
`434`	`434`	`}`
`435`	`435`	`// PyDict_SetItem increases ref count, so we need to decref here`
`436`	`436`	`Py_DECREF(child_value); // child_value: 1 refcount`
`@@ -449,7 +449,7 @@ static PyObject *_get_annotations = nullptr;`
`449`	`449`	`inline PyObject get_annotations(PyObject clz)`
`450`	`450`	`{`
`451`	`451`	`#if PY_VERSION_HEX >= 0x030e0000`
`452`		`- return PyObject_CallFunctionObjArgs(_get_annotations, clz, NULL);`
	`452`	`+ return PyObject_CallFunctionObjArgs(_get_annotations, clz, nullptr);`
`453`	`453`	`#else`
`454`	`454`	`return PyObject_GetAttrString(clz, "__annotations__");`
`455`	`455`	`#endif`
`@@ -468,9 +468,9 @@ inline PyObject parse_class(PyObject kwargs, TypeTreeNodeObject *node, TypeTre`
`468`	`468`	`// slots check`
`469`	`469`	`PyObject *slots = nullptr;`
`470`	`470`
`471`		`- if (kwargs == NULL)`
	`471`	`+ if (kwargs == nullptr)`
`472`	`472`	`{`
`473`		`- return NULL;`
	`473`	`+ return nullptr;`
`474`	`474`	`}`
`475`	`475`
`476`	`476`	`if (node->_data_type == NodeDataType::PPtr)`
`@@ -587,27 +587,27 @@ TypeTreeNodeObject get_ref_type_node(PyObject ref_object, PyObject *assetsfile`
`587`	`587`	`if (assetsfile == Py_None)`
`588`	`588`	`{`
`589`	`589`	`PyErr_SetString(PyExc_ValueError, "Reference Type found but no SerializedFile passed as assetsfile to read_typetree!");`
`590`		`- return NULL;`
	`590`	`+ return nullptr;`
`591`	`591`	`}`
`592`	`592`	`PyObject *ref_types = PyObject_GetAttrString(assetsfile, "ref_types");`
`593`	`593`	`if (!ref_types \|\| !PyList_Check(ref_types))`
`594`	`594`	`{`
`595`	`595`	`Py_XDECREF(ref_types);`
`596`	`596`	`PyErr_SetString(PyExc_ValueError, "No SerializedFile.ref_types");`
`597`		`- return NULL;`
	`597`	`+ return nullptr;`
`598`	`598`	`}`
`599`	`599`
`600`	`600`	`PyObject *type = PyDict_GetItemString(ref_object, "type");`
`601`	`601`	`if (!type)`
`602`	`602`	`{`
`603`	`603`	`Py_DECREF(ref_types);`
`604`	`604`	`PyErr_SetString(PyExc_ValueError, "Failed to get 'type'");`
`605`		`- return NULL;`
	`605`	`+ return nullptr;`
`606`	`606`	`}`
`607`	`607`
`608`		`- PyObject *cls = NULL;`
`609`		`- PyObject *ns = NULL;`
`610`		`- PyObject *asm_ = NULL;`
	`608`	`+ PyObject *cls = nullptr;`
	`609`	`+ PyObject *ns = nullptr;`
	`610`	`+ PyObject *asm_ = nullptr;`
`611`	`611`	`if (PyDict_Check(type))`
`612`	`612`	`{`
`613`	`613`	`cls = PyDict_GetItemString(type, "class");`
`@@ -631,7 +631,7 @@ TypeTreeNodeObject get_ref_type_node(PyObject ref_object, PyObject *assetsfile`
`631`	`631`	`Py_XDECREF(ns);`
`632`	`632`	`Py_XDECREF(asm_);`
`633`	`633`	`PyErr_SetString(PyExc_ValueError, "Failed to get 'class', 'ns' or 'asm'");`
`634`		`- return NULL;`
	`634`	`+ return nullptr;`
`635`	`635`	`}`
`636`	`636`
`637`	`637`	`if (PyUnicode_GET_LENGTH(cls) == 0)`
`@@ -644,7 +644,7 @@ TypeTreeNodeObject get_ref_type_node(PyObject ref_object, PyObject *assetsfile`
`644`	`644`	`}`
`645`	`645`
`646`	`646`	`Py_ssize_t ref_types_len = PyList_Size(ref_types);`
`647`		`- TypeTreeNodeObject *ref_type_node = NULL;`
	`647`	`+ TypeTreeNodeObject *ref_type_node = nullptr;`
`648`	`648`	`for (Py_ssize_t i = 0; i < ref_types_len; i++)`
`649`	`649`	`{`
`650`	`650`	`PyObject *ref_type = PyList_GetItem(ref_types, i);`
`@@ -762,7 +762,7 @@ PyObject read_typetree_value(ReaderT reader, TypeTreeNodeObject *node, TypeTre`
`762`	`762`	`{`
`763`	`763`	`PyErr_SetString(PyExc_ValueError, "Failed to get ref type node");`
`764`	`764`	`Py_DECREF(value);`
`765`		`- return NULL;`
	`765`	`+ return nullptr;`
`766`	`766`	`}`
`767`	`767`	`else if (ref_node == (TypeTreeNodeObject *)Py_None)`
`768`	`768`	`{`
`@@ -777,28 +777,28 @@ PyObject read_typetree_value(ReaderT reader, TypeTreeNodeObject *node, TypeTre`
`777`	`777`	`child_value = read_typetree_value<swap>(reader, child, config);`
`778`	`778`	`}`
`779`	`779`
`780`		`- if (child_value == NULL)`
	`780`	`+ if (child_value == nullptr)`
`781`	`781`	`{`
`782`	`782`	`Py_DECREF(value);`
`783`		`- return NULL;`
	`783`	`+ return nullptr;`
`784`	`784`	`}`
`785`	`785`	`if (PyDict_SetItem(value, child->m_Name, child_value))`
`786`	`786`	`{`
`787`	`787`	`Py_DECREF(value);`
`788`	`788`	`Py_DECREF(child_value);`
`789`		`- return NULL;`
	`789`	`+ return nullptr;`
`790`	`790`	`}`
`791`	`791`	`// dict increases ref count, so we need to decref here`
`792`	`792`	`Py_DECREF(child_value);`
`793`	`793`	`}`
`794`	`794`	`if (!config->as_dict)`
`795`	`795`	`{`
`796`	`796`	`PyObject *clz = PyObject_GetAttrString(config->classes, "UnknownObject");`
`797`		`- if (clz == NULL)`
	`797`	`+ if (clz == nullptr)`
`798`	`798`	`{`
`799`	`799`	`PyErr_SetString(PyExc_ValueError, "Failed to get class");`
`800`	`800`	`Py_DECREF(value);`
`801`		`- return NULL;`
	`801`	`+ return nullptr;`
`802`	`802`	`}`
`803`	`803`	`PyObject args = PyTuple_Pack(1, (PyObject )node);`
`804`	`804`	`PyObject *instance = PyObject_Call(clz, args, value);`
`@@ -822,7 +822,7 @@ PyObject read_typetree_value(ReaderT reader, TypeTreeNodeObject *node, TypeTre`
`822`	`822`	`if (PyList_GET_SIZE(child->m_Children) != 2)`
`823`	`823`	`{`
`824`	`824`	`PyErr_SetString(PyExc_ValueError, "Array node must have 2 children");`
`825`		`- return NULL;`
	`825`	`+ return nullptr;`
`826`	`826`	`}`
`827`	`827`
`828`	`828`	`if (child->_align)`
`@@ -832,24 +832,24 @@ PyObject read_typetree_value(ReaderT reader, TypeTreeNodeObject *node, TypeTre`
`832`	`832`	`int32_t length;`
`833`	`833`	`if (!_read_length<swap>(reader, &length))`
`834`	`834`	`{`
`835`		`- return NULL;`
	`835`	`+ return nullptr;`
`836`	`836`	`}`
`837`	`837`
`838`	`838`	`child = (TypeTreeNodeObject *)PyList_GET_ITEM(child->m_Children, 1);`
`839`	`839`	`if (std::find(std::begin(SUPPORTED_VALUE_ARRAY_READ_TYPES), std::end(SUPPORTED_VALUE_ARRAY_READ_TYPES), child->_data_type) == std::end(SUPPORTED_VALUE_ARRAY_READ_TYPES))`
`840`	`840`	`{`
`841`	`841`	`value = PyList_New(length);`
`842`		`- if (value == NULL)`
	`842`	`+ if (value == nullptr)`
`843`	`843`	`{`
`844`		`- return NULL;`
	`844`	`+ return nullptr;`
`845`	`845`	`}`
`846`	`846`	`for (int i = 0; i < length; i++)`
`847`	`847`	`{`
`848`	`848`	`PyObject *item = read_typetree_value<swap>(reader, child, config);`
`849`		`- if (item == NULL)`
	`849`	`+ if (item == nullptr)`
`850`	`850`	`{`
`851`	`851`	`Py_DECREF(value);`
`852`		`- return NULL;`
	`852`	`+ return nullptr;`
`853`	`853`	`}`
`854`	`854`	`PyList_SET_ITEM(value, i, item);`
`855`	`855`	`}`
`@@ -874,7 +874,7 @@ PyObject read_typetree_value(ReaderT reader, TypeTreeNodeObject *node, TypeTre`
`874`	`874`	`}`
`875`	`875`	`}`
`876`	`876`
`877`		`- if (align && value != NULL)`
	`877`	`+ if (align && value != nullptr)`
`878`	`878`	`{`
`879`	`879`	`align4(reader);`
`880`	`880`	`}`
`@@ -931,7 +931,7 @@ PyObject read_typetree_value_array(ReaderT reader, TypeTreeNodeObject *node, T`
`931`	`931`	`PyErr_SetString(PyExc_TypeError, error_msg.c_str());`
`932`	`932`	`value = nullptr;`
`933`	`933`	`}`
`934`		`- if (align && value != NULL)`
	`934`	`+ if (align && value != nullptr)`
`935`	`935`	`{`
`936`	`936`	`align4(reader);`
`937`	`937`	`}`
`@@ -961,7 +961,7 @@ static bool is_null_none_or_type(PyObject obj, PyTypeObject type, const char *`
`961`	`961`
`962`	`962`	`PyObject read_typetree(PyObject self, PyObject args, PyObject kwargs)`
`963`	`963`	`{`
`964`		`- const char *kwlist[] = {"data", "node", "endian", "as_dict", "assetsfile", "classes", NULL};`
	`964`	`+ const char *kwlist[] = {"data", "node", "endian", "as_dict", "assetsfile", "classes", nullptr};`
`965`	`965`	`Py_buffer view;`
`966`	`966`	`PyObject *node = nullptr;`
`967`	`967`	`int as_dict = 1;`
`@@ -1027,7 +1027,7 @@ PyObject read_typetree(PyObject self, PyObject args, PyObject kwargs)`
`1027`	`1027`	`Py_DECREF(config.assetfile);`
`1028`	`1028`	`Py_DECREF(config.classes);`
`1029`	`1029`	`PyErr_SetString(PyExc_ValueError, "Invalid endian");`
`1030`		`- return NULL;`
	`1030`	`+ return nullptr;`
`1031`	`1031`	`}`
`1032`	`1032`	`}`
`1033`	`1033`
`@@ -1052,7 +1052,7 @@ PyObject read_typetree(PyObject self, PyObject args, PyObject kwargs)`
`1052`	`1052`	`Py_XDECREF(config.assetfile);`
`1053`	`1053`	`Py_XDECREF(config.classes);`
`1054`	`1054`
`1055`		`- return (value != NULL) ? Py_BuildValue("(Nn)", value, bytes_read) : NULL;`
	`1055`	`+ return (value != nullptr) ? Py_BuildValue("(Nn)", value, bytes_read) : nullptr;`
`1056`	`1056`	`}`
`1057`	`1057`
`1058`	`1058`	`// TypeTreeNode impl`
`@@ -1141,7 +1141,7 @@ static int TypeTreeNode_init(TypeTreeNodeObject self, PyObject args, PyObject`
`1141`	`1141`	`"m_Index",`
`1142`	`1142`	`"m_MetaFlag",`
`1143`	`1143`	`"m_RefTypeHash",`
`1144`		`- NULL};`
	`1144`	`+ nullptr};`
`1145`	`1145`
`1146`	`1146`	`// ensure all fields are set to 0`
`1147`	`1147`	`// in case init fails, so that dealloc doesn't segfault`
`@@ -1244,16 +1244,16 @@ static PyMemberDef TypeTreeNode_members[] = {`
`1244`	`1244`	`{"m_MetaFlag", T_OBJECT_EX, offsetof(TypeTreeNodeObject, m_MetaFlag), 0, ""},`
`1245`	`1245`	`{"m_RefTypeHash", T_OBJECT_EX, offsetof(TypeTreeNodeObject, m_RefTypeHash), 0, ""},`
`1246`	`1246`	`{"_clean_name", T_OBJECT_EX, offsetof(TypeTreeNodeObject, _clean_name), 0, ""},`
`1247`		`- {NULL} /* Sentinel */`
	`1247`	`+ {nullptr} /* Sentinel */`
`1248`	`1248`	`};`
`1249`	`1249`
`1250`	`1250`	`static PyTypeObject TypeTreeNodeType = []() -> PyTypeObject`
`1251`	`1251`	`{`
`1252`	`1252`	`PyTypeObject type = {`
`1253`	`1253`	`#if PY_VERSION_HEX >= 0x03080000`
`1254`		`- PyVarObject_HEAD_INIT(NULL, 0)`
	`1254`	`+ PyVarObject_HEAD_INIT(nullptr, 0)`
`1255`	`1255`	`#else`
`1256`		`- PyObject_HEAD_INIT(NULL) 0`
	`1256`	`+ PyObject_HEAD_INIT(nullptr) 0`
`1257`	`1257`	`#endif`
`1258`	`1258`	`};`
`1259`	`1259`	`type.tp_name = "TypeTreeHelper.TypeTreeNode";`