Nuitka-winsvc 2.2.3__cp311-cp311-win_amd64.whl → 2.3__cp311-cp311-win_amd64.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (198) hide show
  1. {Nuitka_winsvc-2.2.3.dist-info → Nuitka_winsvc-2.3.dist-info}/METADATA +1 -1
  2. {Nuitka_winsvc-2.2.3.dist-info → Nuitka_winsvc-2.3.dist-info}/RECORD +198 -197
  3. nuitka/Bytecodes.py +4 -2
  4. nuitka/HardImportRegistry.py +1 -0
  5. nuitka/MainControl.py +16 -10
  6. nuitka/ModuleRegistry.py +15 -0
  7. nuitka/OptionParsing.py +30 -8
  8. nuitka/Options.py +104 -44
  9. nuitka/PostProcessing.py +9 -8
  10. nuitka/PythonVersions.py +2 -1
  11. nuitka/Serialization.py +47 -30
  12. nuitka/Version.py +1 -1
  13. nuitka/build/Backend.scons +46 -19
  14. nuitka/build/CCompilerVersion.scons +3 -3
  15. nuitka/build/Onefile.scons +4 -4
  16. nuitka/build/SconsCaching.py +3 -2
  17. nuitka/build/SconsCompilerSettings.py +11 -5
  18. nuitka/build/SconsInterface.py +22 -6
  19. nuitka/build/SconsUtils.py +9 -1
  20. nuitka/build/include/nuitka/allocator.h +58 -2
  21. nuitka/build/include/nuitka/compiled_frame.h +48 -13
  22. nuitka/build/include/nuitka/compiled_function.h +4 -0
  23. nuitka/build/include/nuitka/constants.h +6 -0
  24. nuitka/build/include/nuitka/exception_groups.h +6 -6
  25. nuitka/build/include/nuitka/exceptions.h +3 -3
  26. nuitka/build/include/nuitka/freelists.h +11 -0
  27. nuitka/build/include/nuitka/helper/dictionaries.h +5 -4
  28. nuitka/build/include/nuitka/helper/lists.h +5 -5
  29. nuitka/build/include/nuitka/helper/lists_generated.h +12 -12
  30. nuitka/build/include/nuitka/helper/sequences.h +6 -0
  31. nuitka/build/include/nuitka/helper/slices.h +14 -8
  32. nuitka/build/include/nuitka/helper/subscripts.h +1 -184
  33. nuitka/build/include/nuitka/helper/tuples.h +42 -33
  34. nuitka/build/include/nuitka/importing.h +5 -0
  35. nuitka/build/include/nuitka/prelude.h +35 -2
  36. nuitka/build/include/nuitka/safe_string_ops.h +1 -0
  37. nuitka/build/include/nuitka/threading.h +13 -10
  38. nuitka/build/static_src/CompiledAsyncgenType.c +19 -8
  39. nuitka/build/static_src/CompiledCellType.c +1 -1
  40. nuitka/build/static_src/CompiledCodeHelpers.c +18 -16
  41. nuitka/build/static_src/CompiledCoroutineType.c +23 -19
  42. nuitka/build/static_src/CompiledFrameType.c +46 -34
  43. nuitka/build/static_src/CompiledFunctionType.c +55 -34
  44. nuitka/build/static_src/CompiledGeneratorType.c +21 -19
  45. nuitka/build/static_src/CompiledGeneratorTypeUncompiledIntegration.c +127 -130
  46. nuitka/build/static_src/CompiledMethodType.c +15 -17
  47. nuitka/build/static_src/HelpersAllocator.c +71 -0
  48. nuitka/build/static_src/HelpersAttributes.c +1 -1
  49. nuitka/build/static_src/HelpersBuiltin.c +5 -5
  50. nuitka/build/static_src/HelpersBytes.c +2 -2
  51. nuitka/build/static_src/HelpersCalling.c +3 -0
  52. nuitka/build/static_src/HelpersCallingGenerated.c +131 -131
  53. nuitka/build/static_src/HelpersComparisonEq.c +329 -329
  54. nuitka/build/static_src/HelpersComparisonEqUtils.c +3 -1
  55. nuitka/build/static_src/HelpersComparisonGe.c +322 -322
  56. nuitka/build/static_src/HelpersComparisonGt.c +321 -321
  57. nuitka/build/static_src/HelpersComparisonLe.c +322 -322
  58. nuitka/build/static_src/HelpersComparisonLt.c +321 -321
  59. nuitka/build/static_src/HelpersComparisonNe.c +329 -329
  60. nuitka/build/static_src/HelpersConsole.c +96 -0
  61. nuitka/build/static_src/HelpersConstantsBlob.c +10 -6
  62. nuitka/build/static_src/HelpersDeepcopy.c +10 -8
  63. nuitka/build/static_src/HelpersDictionaries.c +17 -11
  64. nuitka/build/static_src/HelpersDictionariesGenerated.c +65 -29
  65. nuitka/build/static_src/HelpersExceptions.c +107 -9
  66. nuitka/build/static_src/HelpersFilesystemPaths.c +64 -4
  67. nuitka/build/static_src/HelpersFloats.c +20 -14
  68. nuitka/build/static_src/HelpersImport.c +1 -1
  69. nuitka/build/static_src/HelpersJitSources.c +1 -1
  70. nuitka/build/static_src/HelpersLists.c +29 -19
  71. nuitka/build/static_src/HelpersListsGenerated.c +24 -24
  72. nuitka/build/static_src/HelpersMatching.c +32 -5
  73. nuitka/build/static_src/HelpersOperationBinaryAdd.c +90 -63
  74. nuitka/build/static_src/HelpersOperationBinaryAddUtils.c +4 -4
  75. nuitka/build/static_src/HelpersOperationBinaryBitand.c +33 -33
  76. nuitka/build/static_src/HelpersOperationBinaryBitor.c +33 -33
  77. nuitka/build/static_src/HelpersOperationBinaryBitxor.c +33 -33
  78. nuitka/build/static_src/HelpersOperationBinaryDivmod.c +24 -24
  79. nuitka/build/static_src/HelpersOperationBinaryFloordiv.c +24 -24
  80. nuitka/build/static_src/HelpersOperationBinaryLshift.c +30 -30
  81. nuitka/build/static_src/HelpersOperationBinaryMatmult.c +7 -7
  82. nuitka/build/static_src/HelpersOperationBinaryMod.c +90 -90
  83. nuitka/build/static_src/HelpersOperationBinaryMult.c +64 -58
  84. nuitka/build/static_src/HelpersOperationBinaryOlddiv.c +24 -24
  85. nuitka/build/static_src/HelpersOperationBinaryPow.c +27 -27
  86. nuitka/build/static_src/HelpersOperationBinaryRshift.c +30 -30
  87. nuitka/build/static_src/HelpersOperationBinarySub.c +24 -24
  88. nuitka/build/static_src/HelpersOperationBinaryTruediv.c +24 -24
  89. nuitka/build/static_src/HelpersOperationInplaceAdd.c +67 -49
  90. nuitka/build/static_src/HelpersOperationInplaceBitand.c +25 -25
  91. nuitka/build/static_src/HelpersOperationInplaceBitor.c +25 -25
  92. nuitka/build/static_src/HelpersOperationInplaceBitxor.c +25 -25
  93. nuitka/build/static_src/HelpersOperationInplaceFloordiv.c +28 -28
  94. nuitka/build/static_src/HelpersOperationInplaceLshift.c +18 -18
  95. nuitka/build/static_src/HelpersOperationInplaceMatmult.c +10 -10
  96. nuitka/build/static_src/HelpersOperationInplaceMod.c +70 -70
  97. nuitka/build/static_src/HelpersOperationInplaceMult.c +33 -33
  98. nuitka/build/static_src/HelpersOperationInplaceOlddiv.c +28 -28
  99. nuitka/build/static_src/HelpersOperationInplacePow.c +28 -28
  100. nuitka/build/static_src/HelpersOperationInplaceRshift.c +18 -18
  101. nuitka/build/static_src/HelpersOperationInplaceSub.c +28 -28
  102. nuitka/build/static_src/HelpersOperationInplaceTruediv.c +28 -28
  103. nuitka/build/static_src/HelpersRaising.c +10 -3
  104. nuitka/build/static_src/HelpersSafeStrings.c +14 -4
  105. nuitka/build/static_src/HelpersSlices.c +12 -5
  106. nuitka/build/static_src/HelpersStrings.c +1 -1
  107. nuitka/build/static_src/HelpersTuples.c +20 -15
  108. nuitka/build/static_src/InspectPatcher.c +74 -6
  109. nuitka/build/static_src/MainProgram.c +90 -25
  110. nuitka/build/static_src/MetaPathBasedLoader.c +81 -45
  111. nuitka/build/static_src/MetaPathBasedLoaderResourceReaderFiles.c +2 -2
  112. nuitka/build/static_src/OnefileBootstrap.c +16 -17
  113. nuitka/code_generation/CodeGeneration.py +5 -2
  114. nuitka/code_generation/ConstantCodes.py +2 -2
  115. nuitka/code_generation/DictCodes.py +2 -2
  116. nuitka/code_generation/GlobalConstants.py +5 -0
  117. nuitka/code_generation/GlobalsLocalsCodes.py +2 -2
  118. nuitka/code_generation/ListCodes.py +2 -2
  119. nuitka/code_generation/LocalsDictCodes.py +1 -1
  120. nuitka/code_generation/ModuleCodes.py +19 -0
  121. nuitka/code_generation/PackageResourceCodes.py +14 -0
  122. nuitka/code_generation/SliceCodes.py +3 -3
  123. nuitka/code_generation/SubscriptCodes.py +5 -13
  124. nuitka/code_generation/TupleCodes.py +1 -1
  125. nuitka/code_generation/c_types/CTypePyObjectPointers.py +7 -7
  126. nuitka/code_generation/templates/CodeTemplatesConstants.py +7 -5
  127. nuitka/code_generation/templates/CodeTemplatesLoader.py +2 -0
  128. nuitka/code_generation/templates/CodeTemplatesModules.py +78 -54
  129. nuitka/code_generation/templates_c/CodeTemplateCallsMixed.c.j2 +1 -1
  130. nuitka/code_generation/templates_c/CodeTemplateCallsPositional.c.j2 +8 -8
  131. nuitka/code_generation/templates_c/CodeTemplateCallsPositionalMethodDescr.c.j2 +5 -5
  132. nuitka/code_generation/templates_c/CodeTemplateMakeListHinted.c.j2 +2 -2
  133. nuitka/code_generation/templates_c/CodeTemplateMakeListSmall.c.j2 +2 -2
  134. nuitka/code_generation/templates_c/HelperDictionaryCopy.c.j2 +57 -21
  135. nuitka/code_generation/templates_c/HelperImportHard.c.j2 +1 -1
  136. nuitka/code_generation/templates_c/HelperOperationBinary.c.j2 +5 -5
  137. nuitka/code_generation/templates_c/HelperOperationComparison.c.j2 +18 -18
  138. nuitka/code_generation/templates_c/HelperOperationComparisonBytes.c.j2 +11 -11
  139. nuitka/code_generation/templates_c/HelperOperationComparisonFloat.c.j2 +3 -3
  140. nuitka/code_generation/templates_c/HelperOperationComparisonInt.c.j2 +3 -3
  141. nuitka/code_generation/templates_c/HelperOperationComparisonList.c.j2 +7 -7
  142. nuitka/code_generation/templates_c/HelperOperationComparisonLong.c.j2 +3 -3
  143. nuitka/code_generation/templates_c/HelperOperationComparisonStr.c.j2 +11 -11
  144. nuitka/code_generation/templates_c/HelperOperationComparisonTuple.c.j2 +7 -7
  145. nuitka/code_generation/templates_c/HelperOperationComparisonUnicode.c.j2 +10 -10
  146. nuitka/code_generation/templates_c/HelperOperationInplace.c.j2 +1 -1
  147. nuitka/code_generation/templates_c/HelperSlotsBinary.c.j2 +3 -3
  148. nuitka/code_generation/templates_c/HelperSlotsList.c.j2 +4 -1
  149. nuitka/code_generation/templates_c/HelperSlotsTuple.c.j2 +4 -1
  150. nuitka/finalizations/FinalizeMarkups.py +0 -18
  151. nuitka/freezer/DependsExe.py +9 -4
  152. nuitka/freezer/DllDependenciesMacOS.py +1 -1
  153. nuitka/freezer/DllDependenciesWin32.py +1 -1
  154. nuitka/freezer/ImportDetection.py +1 -0
  155. nuitka/freezer/IncludedDataFiles.py +13 -4
  156. nuitka/freezer/Onefile.py +0 -1
  157. nuitka/freezer/Standalone.py +3 -1
  158. nuitka/importing/ImportCache.py +3 -2
  159. nuitka/importing/Importing.py +16 -3
  160. nuitka/importing/StandardLibrary.py +4 -0
  161. nuitka/nodes/ChildrenHavingMixins.py +2 -0
  162. nuitka/nodes/ExpressionBasesGenerated.py +4 -0
  163. nuitka/nodes/HardImportNodesGenerated.py +83 -0
  164. nuitka/nodes/ModuleNodes.py +10 -2
  165. nuitka/nodes/OsSysNodes.py +16 -0
  166. nuitka/nodes/SubscriptNodes.py +3 -3
  167. nuitka/plugins/PluginBase.py +2 -0
  168. nuitka/plugins/standard/DataFilesPlugin.py +22 -1
  169. nuitka/plugins/standard/DillPlugin/DillPlugin.c +3 -3
  170. nuitka/plugins/standard/OptionsNannyPlugin.py +9 -41
  171. nuitka/plugins/standard/PkgResourcesPlugin.py +8 -2
  172. nuitka/plugins/standard/PySidePyQtPlugin.py +3 -0
  173. nuitka/plugins/standard/standard.nuitka-package.config.yml +18 -12
  174. nuitka/plugins/standard/stdlib2.nuitka-package.config.yml +2 -2
  175. nuitka/plugins/standard/stdlib3.nuitka-package.config.yml +2 -2
  176. nuitka/specs/HardImportSpecs.py +3 -0
  177. nuitka/specs/ParameterSpecs.py +26 -15
  178. nuitka/tools/general/find_module/FindModuleCode.py +3 -2
  179. nuitka/tools/specialize/CTypeDescriptions.py +11 -9
  180. nuitka/tools/testing/Common.py +12 -5
  181. nuitka/tools/testing/SearchModes.py +5 -1
  182. nuitka/tools/watch/GitHub.py +1 -7
  183. nuitka/tree/Building.py +9 -6
  184. nuitka/tree/ReformulationMatchStatements.py +39 -3
  185. nuitka/tree/TreeHelpers.py +8 -0
  186. nuitka/utils/CStrings.py +7 -0
  187. nuitka/utils/Execution.py +10 -1
  188. nuitka/utils/FileOperations.py +21 -13
  189. nuitka/utils/Importing.py +24 -0
  190. nuitka/utils/ReExecute.py +7 -3
  191. nuitka/utils/SharedLibraries.py +17 -0
  192. nuitka/utils/Yaml.py +9 -1
  193. {Nuitka_winsvc-2.2.3.data → Nuitka_winsvc-2.3.data}/scripts/nuitka-run.bat +0 -0
  194. {Nuitka_winsvc-2.2.3.data → Nuitka_winsvc-2.3.data}/scripts/nuitka.bat +0 -0
  195. {Nuitka_winsvc-2.2.3.dist-info → Nuitka_winsvc-2.3.dist-info}/LICENSE.txt +0 -0
  196. {Nuitka_winsvc-2.2.3.dist-info → Nuitka_winsvc-2.3.dist-info}/WHEEL +0 -0
  197. {Nuitka_winsvc-2.2.3.dist-info → Nuitka_winsvc-2.3.dist-info}/entry_points.txt +0 -0
  198. {Nuitka_winsvc-2.2.3.dist-info → Nuitka_winsvc-2.3.dist-info}/top_level.txt +0 -0
@@ -24,7 +24,7 @@ static PyObject *COMPARE_EQ_OBJECT_INT_INT(PyObject *operand1, PyObject *operand
24
24
 
25
25
  // Convert to target type.
26
26
  PyObject *result = BOOL_FROM(r);
27
- Py_INCREF(result);
27
+ Py_INCREF_IMMORTAL(result);
28
28
  return result;
29
29
  }
30
30
  #endif
@@ -59,7 +59,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
59
59
  if (operand1 == operand2 && IS_SANE_TYPE(Py_TYPE(operand1))) {
60
60
  bool r = true;
61
61
  PyObject *result = BOOL_FROM(r);
62
- Py_INCREF(result);
62
+ Py_INCREF_IMMORTAL(result);
63
63
  return result;
64
64
  }
65
65
 
@@ -91,7 +91,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
91
91
  return result;
92
92
  }
93
93
 
94
- Py_DECREF(result);
94
+ Py_DECREF_IMMORTAL(result);
95
95
  }
96
96
 
97
97
  // No rich comparison worked, but maybe compare works.
@@ -132,7 +132,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
132
132
 
133
133
  bool r = c != 0;
134
134
  PyObject *result = BOOL_FROM(r);
135
- Py_INCREF(result);
135
+ Py_INCREF_IMMORTAL(result);
136
136
  return result;
137
137
  }
138
138
  }
@@ -152,7 +152,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
152
152
  return result;
153
153
  }
154
154
 
155
- Py_DECREF(result);
155
+ Py_DECREF_IMMORTAL(result);
156
156
  }
157
157
  }
158
158
 
@@ -166,7 +166,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
166
166
  return result;
167
167
  }
168
168
 
169
- Py_DECREF(result);
169
+ Py_DECREF_IMMORTAL(result);
170
170
  }
171
171
 
172
172
  f = RICHCOMPARE(type2);
@@ -179,7 +179,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
179
179
  return result;
180
180
  }
181
181
 
182
- Py_DECREF(result);
182
+ Py_DECREF_IMMORTAL(result);
183
183
  }
184
184
 
185
185
  int c;
@@ -267,7 +267,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
267
267
 
268
268
  bool r = c != 0;
269
269
  PyObject *result = BOOL_FROM(r);
270
- Py_INCREF(result);
270
+ Py_INCREF_IMMORTAL(result);
271
271
  return result;
272
272
  #else
273
273
  bool checked_reverse_op = false;
@@ -287,7 +287,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
287
287
  return result;
288
288
  }
289
289
 
290
- Py_DECREF(result);
290
+ Py_DECREF_IMMORTAL(result);
291
291
  }
292
292
  }
293
293
 
@@ -302,7 +302,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
302
302
  return result;
303
303
  }
304
304
 
305
- Py_DECREF(result);
305
+ Py_DECREF_IMMORTAL(result);
306
306
  }
307
307
 
308
308
  if (checked_reverse_op == false) {
@@ -317,7 +317,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
317
317
  return result;
318
318
  }
319
319
 
320
- Py_DECREF(result);
320
+ Py_DECREF_IMMORTAL(result);
321
321
  }
322
322
  }
323
323
 
@@ -329,13 +329,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_OBJECT(PyObject *operand1, PyObject *ope
329
329
  case Py_EQ: {
330
330
  bool r = operand1 == operand2;
331
331
  PyObject *result = BOOL_FROM(r);
332
- Py_INCREF(result);
332
+ Py_INCREF_IMMORTAL(result);
333
333
  return result;
334
334
  }
335
335
  case Py_NE: {
336
336
  bool r = operand1 != operand2;
337
337
  PyObject *result = BOOL_FROM(r);
338
- Py_INCREF(result);
338
+ Py_INCREF_IMMORTAL(result);
339
339
  return result;
340
340
  }
341
341
  default:
@@ -403,7 +403,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *op
403
403
  }
404
404
  }
405
405
 
406
- Py_DECREF(result);
406
+ Py_DECREF_IMMORTAL(result);
407
407
  }
408
408
 
409
409
  // No rich comparison worked, but maybe compare works.
@@ -472,7 +472,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *op
472
472
  }
473
473
  }
474
474
 
475
- Py_DECREF(result);
475
+ Py_DECREF_IMMORTAL(result);
476
476
  }
477
477
  }
478
478
 
@@ -494,7 +494,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *op
494
494
  }
495
495
  }
496
496
 
497
- Py_DECREF(result);
497
+ Py_DECREF_IMMORTAL(result);
498
498
  }
499
499
 
500
500
  f = RICHCOMPARE(type2);
@@ -515,7 +515,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *op
515
515
  }
516
516
  }
517
517
 
518
- Py_DECREF(result);
518
+ Py_DECREF_IMMORTAL(result);
519
519
  }
520
520
 
521
521
  int c;
@@ -631,7 +631,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *op
631
631
  }
632
632
  }
633
633
 
634
- Py_DECREF(result);
634
+ Py_DECREF_IMMORTAL(result);
635
635
  }
636
636
  }
637
637
 
@@ -654,7 +654,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *op
654
654
  }
655
655
  }
656
656
 
657
- Py_DECREF(result);
657
+ Py_DECREF_IMMORTAL(result);
658
658
  }
659
659
 
660
660
  if (checked_reverse_op == false) {
@@ -677,7 +677,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_OBJECT(PyObject *operand1, PyObject *op
677
677
  }
678
678
  }
679
679
 
680
- Py_DECREF(result);
680
+ Py_DECREF_IMMORTAL(result);
681
681
  }
682
682
  }
683
683
 
@@ -726,7 +726,7 @@ static PyObject *COMPARE_EQ_OBJECT_STR_STR(PyObject *operand1, PyObject *operand
726
726
 
727
727
  // Convert to target type.
728
728
  PyObject *result = BOOL_FROM(r);
729
- Py_INCREF(result);
729
+ Py_INCREF_IMMORTAL(result);
730
730
  return result;
731
731
  }
732
732
 
@@ -738,7 +738,7 @@ static PyObject *COMPARE_EQ_OBJECT_STR_STR(PyObject *operand1, PyObject *operand
738
738
 
739
739
  // Convert to target type.
740
740
  PyObject *result = BOOL_FROM(r);
741
- Py_INCREF(result);
741
+ Py_INCREF_IMMORTAL(result);
742
742
  return result;
743
743
  } else {
744
744
  if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
@@ -746,14 +746,14 @@ static PyObject *COMPARE_EQ_OBJECT_STR_STR(PyObject *operand1, PyObject *operand
746
746
 
747
747
  // Convert to target type.
748
748
  PyObject *result = BOOL_FROM(r);
749
- Py_INCREF(result);
749
+ Py_INCREF_IMMORTAL(result);
750
750
  return result;
751
751
  } else {
752
752
  bool r = false;
753
753
 
754
754
  // Convert to target type.
755
755
  PyObject *result = BOOL_FROM(r);
756
- Py_INCREF(result);
756
+ Py_INCREF_IMMORTAL(result);
757
757
  return result;
758
758
  }
759
759
  }
@@ -792,7 +792,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
792
792
  return result;
793
793
  }
794
794
 
795
- Py_DECREF(result);
795
+ Py_DECREF_IMMORTAL(result);
796
796
  }
797
797
 
798
798
  // No rich comparison worked, but maybe compare works.
@@ -833,7 +833,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
833
833
 
834
834
  bool r = c != 0;
835
835
  PyObject *result = BOOL_FROM(r);
836
- Py_INCREF(result);
836
+ Py_INCREF_IMMORTAL(result);
837
837
  return result;
838
838
  }
839
839
  }
@@ -853,7 +853,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
853
853
  return result;
854
854
  }
855
855
 
856
- Py_DECREF(result);
856
+ Py_DECREF_IMMORTAL(result);
857
857
  }
858
858
  }
859
859
 
@@ -867,7 +867,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
867
867
  return result;
868
868
  }
869
869
 
870
- Py_DECREF(result);
870
+ Py_DECREF_IMMORTAL(result);
871
871
  }
872
872
 
873
873
  f = PyString_Type.tp_richcompare;
@@ -880,7 +880,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
880
880
  return result;
881
881
  }
882
882
 
883
- Py_DECREF(result);
883
+ Py_DECREF_IMMORTAL(result);
884
884
  }
885
885
 
886
886
  int c;
@@ -968,7 +968,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
968
968
 
969
969
  bool r = c != 0;
970
970
  PyObject *result = BOOL_FROM(r);
971
- Py_INCREF(result);
971
+ Py_INCREF_IMMORTAL(result);
972
972
  return result;
973
973
  #else
974
974
  bool checked_reverse_op = false;
@@ -988,7 +988,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
988
988
  return result;
989
989
  }
990
990
 
991
- Py_DECREF(result);
991
+ Py_DECREF_IMMORTAL(result);
992
992
  }
993
993
  }
994
994
 
@@ -1003,7 +1003,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
1003
1003
  return result;
1004
1004
  }
1005
1005
 
1006
- Py_DECREF(result);
1006
+ Py_DECREF_IMMORTAL(result);
1007
1007
  }
1008
1008
 
1009
1009
  if (checked_reverse_op == false) {
@@ -1018,7 +1018,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
1018
1018
  return result;
1019
1019
  }
1020
1020
 
1021
- Py_DECREF(result);
1021
+ Py_DECREF_IMMORTAL(result);
1022
1022
  }
1023
1023
  }
1024
1024
 
@@ -1030,13 +1030,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_STR(PyObject *operand1, PyObject *operan
1030
1030
  case Py_EQ: {
1031
1031
  bool r = operand1 == operand2;
1032
1032
  PyObject *result = BOOL_FROM(r);
1033
- Py_INCREF(result);
1033
+ Py_INCREF_IMMORTAL(result);
1034
1034
  return result;
1035
1035
  }
1036
1036
  case Py_NE: {
1037
1037
  bool r = operand1 != operand2;
1038
1038
  PyObject *result = BOOL_FROM(r);
1039
- Py_INCREF(result);
1039
+ Py_INCREF_IMMORTAL(result);
1040
1040
  return result;
1041
1041
  }
1042
1042
  default:
@@ -1086,7 +1086,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1086
1086
  return result;
1087
1087
  }
1088
1088
 
1089
- Py_DECREF(result);
1089
+ Py_DECREF_IMMORTAL(result);
1090
1090
  }
1091
1091
 
1092
1092
  // No rich comparison worked, but maybe compare works.
@@ -1127,7 +1127,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1127
1127
 
1128
1128
  bool r = c != 0;
1129
1129
  PyObject *result = BOOL_FROM(r);
1130
- Py_INCREF(result);
1130
+ Py_INCREF_IMMORTAL(result);
1131
1131
  return result;
1132
1132
  }
1133
1133
  }
@@ -1147,7 +1147,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1147
1147
  return result;
1148
1148
  }
1149
1149
 
1150
- Py_DECREF(result);
1150
+ Py_DECREF_IMMORTAL(result);
1151
1151
  }
1152
1152
  }
1153
1153
 
@@ -1161,7 +1161,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1161
1161
  return result;
1162
1162
  }
1163
1163
 
1164
- Py_DECREF(result);
1164
+ Py_DECREF_IMMORTAL(result);
1165
1165
  }
1166
1166
 
1167
1167
  f = RICHCOMPARE(type2);
@@ -1174,7 +1174,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1174
1174
  return result;
1175
1175
  }
1176
1176
 
1177
- Py_DECREF(result);
1177
+ Py_DECREF_IMMORTAL(result);
1178
1178
  }
1179
1179
 
1180
1180
  int c;
@@ -1262,7 +1262,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1262
1262
 
1263
1263
  bool r = c != 0;
1264
1264
  PyObject *result = BOOL_FROM(r);
1265
- Py_INCREF(result);
1265
+ Py_INCREF_IMMORTAL(result);
1266
1266
  return result;
1267
1267
  #else
1268
1268
  bool checked_reverse_op = false;
@@ -1282,7 +1282,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1282
1282
  return result;
1283
1283
  }
1284
1284
 
1285
- Py_DECREF(result);
1285
+ Py_DECREF_IMMORTAL(result);
1286
1286
  }
1287
1287
  }
1288
1288
 
@@ -1297,7 +1297,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1297
1297
  return result;
1298
1298
  }
1299
1299
 
1300
- Py_DECREF(result);
1300
+ Py_DECREF_IMMORTAL(result);
1301
1301
  }
1302
1302
 
1303
1303
  if (checked_reverse_op == false) {
@@ -1312,7 +1312,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1312
1312
  return result;
1313
1313
  }
1314
1314
 
1315
- Py_DECREF(result);
1315
+ Py_DECREF_IMMORTAL(result);
1316
1316
  }
1317
1317
  }
1318
1318
 
@@ -1324,13 +1324,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_STR_OBJECT(PyObject *operand1, PyObject *operan
1324
1324
  case Py_EQ: {
1325
1325
  bool r = operand1 == operand2;
1326
1326
  PyObject *result = BOOL_FROM(r);
1327
- Py_INCREF(result);
1327
+ Py_INCREF_IMMORTAL(result);
1328
1328
  return result;
1329
1329
  }
1330
1330
  case Py_NE: {
1331
1331
  bool r = operand1 != operand2;
1332
1332
  PyObject *result = BOOL_FROM(r);
1333
- Py_INCREF(result);
1333
+ Py_INCREF_IMMORTAL(result);
1334
1334
  return result;
1335
1335
  }
1336
1336
  default:
@@ -1451,7 +1451,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *opera
1451
1451
  }
1452
1452
  }
1453
1453
 
1454
- Py_DECREF(result);
1454
+ Py_DECREF_IMMORTAL(result);
1455
1455
  }
1456
1456
 
1457
1457
  // No rich comparison worked, but maybe compare works.
@@ -1520,7 +1520,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *opera
1520
1520
  }
1521
1521
  }
1522
1522
 
1523
- Py_DECREF(result);
1523
+ Py_DECREF_IMMORTAL(result);
1524
1524
  }
1525
1525
  }
1526
1526
 
@@ -1542,7 +1542,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *opera
1542
1542
  }
1543
1543
  }
1544
1544
 
1545
- Py_DECREF(result);
1545
+ Py_DECREF_IMMORTAL(result);
1546
1546
  }
1547
1547
 
1548
1548
  f = PyString_Type.tp_richcompare;
@@ -1563,7 +1563,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *opera
1563
1563
  }
1564
1564
  }
1565
1565
 
1566
- Py_DECREF(result);
1566
+ Py_DECREF_IMMORTAL(result);
1567
1567
  }
1568
1568
 
1569
1569
  int c;
@@ -1679,7 +1679,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *opera
1679
1679
  }
1680
1680
  }
1681
1681
 
1682
- Py_DECREF(result);
1682
+ Py_DECREF_IMMORTAL(result);
1683
1683
  }
1684
1684
  }
1685
1685
 
@@ -1702,7 +1702,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *opera
1702
1702
  }
1703
1703
  }
1704
1704
 
1705
- Py_DECREF(result);
1705
+ Py_DECREF_IMMORTAL(result);
1706
1706
  }
1707
1707
 
1708
1708
  if (checked_reverse_op == false) {
@@ -1725,7 +1725,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_STR(PyObject *operand1, PyObject *opera
1725
1725
  }
1726
1726
  }
1727
1727
 
1728
- Py_DECREF(result);
1728
+ Py_DECREF_IMMORTAL(result);
1729
1729
  }
1730
1730
  }
1731
1731
 
@@ -1801,7 +1801,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *opera
1801
1801
  }
1802
1802
  }
1803
1803
 
1804
- Py_DECREF(result);
1804
+ Py_DECREF_IMMORTAL(result);
1805
1805
  }
1806
1806
 
1807
1807
  // No rich comparison worked, but maybe compare works.
@@ -1870,7 +1870,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *opera
1870
1870
  }
1871
1871
  }
1872
1872
 
1873
- Py_DECREF(result);
1873
+ Py_DECREF_IMMORTAL(result);
1874
1874
  }
1875
1875
  }
1876
1876
 
@@ -1892,7 +1892,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *opera
1892
1892
  }
1893
1893
  }
1894
1894
 
1895
- Py_DECREF(result);
1895
+ Py_DECREF_IMMORTAL(result);
1896
1896
  }
1897
1897
 
1898
1898
  f = RICHCOMPARE(type2);
@@ -1913,7 +1913,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *opera
1913
1913
  }
1914
1914
  }
1915
1915
 
1916
- Py_DECREF(result);
1916
+ Py_DECREF_IMMORTAL(result);
1917
1917
  }
1918
1918
 
1919
1919
  int c;
@@ -2029,7 +2029,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *opera
2029
2029
  }
2030
2030
  }
2031
2031
 
2032
- Py_DECREF(result);
2032
+ Py_DECREF_IMMORTAL(result);
2033
2033
  }
2034
2034
  }
2035
2035
 
@@ -2052,7 +2052,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *opera
2052
2052
  }
2053
2053
  }
2054
2054
 
2055
- Py_DECREF(result);
2055
+ Py_DECREF_IMMORTAL(result);
2056
2056
  }
2057
2057
 
2058
2058
  if (checked_reverse_op == false) {
@@ -2075,7 +2075,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_STR_OBJECT(PyObject *operand1, PyObject *opera
2075
2075
  }
2076
2076
  }
2077
2077
 
2078
- Py_DECREF(result);
2078
+ Py_DECREF_IMMORTAL(result);
2079
2079
  }
2080
2080
  }
2081
2081
 
@@ -2123,7 +2123,7 @@ static PyObject *COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
2123
2123
 
2124
2124
  // Convert to target type.
2125
2125
  PyObject *result = BOOL_FROM(r);
2126
- Py_INCREF(result);
2126
+ Py_INCREF_IMMORTAL(result);
2127
2127
  return result;
2128
2128
  }
2129
2129
 
@@ -2166,7 +2166,7 @@ static PyObject *COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
2166
2166
  }
2167
2167
 
2168
2168
  PyObject *result = BOOL_FROM(r == true);
2169
- Py_INCREF(result);
2169
+ Py_INCREF_IMMORTAL(result);
2170
2170
  return result;
2171
2171
  #else
2172
2172
  bool r;
@@ -2183,7 +2183,7 @@ static PyObject *COMPARE_EQ_OBJECT_UNICODE_UNICODE(PyObject *operand1, PyObject
2183
2183
  }
2184
2184
 
2185
2185
  PyObject *result = BOOL_FROM(r == true);
2186
- Py_INCREF(result);
2186
+ Py_INCREF_IMMORTAL(result);
2187
2187
  return result;
2188
2188
  #endif
2189
2189
  }
@@ -2221,7 +2221,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2221
2221
  return result;
2222
2222
  }
2223
2223
 
2224
- Py_DECREF(result);
2224
+ Py_DECREF_IMMORTAL(result);
2225
2225
  }
2226
2226
 
2227
2227
  // No rich comparison worked, but maybe compare works.
@@ -2262,7 +2262,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2262
2262
 
2263
2263
  bool r = c != 0;
2264
2264
  PyObject *result = BOOL_FROM(r);
2265
- Py_INCREF(result);
2265
+ Py_INCREF_IMMORTAL(result);
2266
2266
  return result;
2267
2267
  }
2268
2268
  }
@@ -2282,7 +2282,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2282
2282
  return result;
2283
2283
  }
2284
2284
 
2285
- Py_DECREF(result);
2285
+ Py_DECREF_IMMORTAL(result);
2286
2286
  }
2287
2287
  }
2288
2288
 
@@ -2296,7 +2296,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2296
2296
  return result;
2297
2297
  }
2298
2298
 
2299
- Py_DECREF(result);
2299
+ Py_DECREF_IMMORTAL(result);
2300
2300
  }
2301
2301
 
2302
2302
  f = PyUnicode_Type.tp_richcompare;
@@ -2309,7 +2309,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2309
2309
  return result;
2310
2310
  }
2311
2311
 
2312
- Py_DECREF(result);
2312
+ Py_DECREF_IMMORTAL(result);
2313
2313
  }
2314
2314
 
2315
2315
  int c;
@@ -2397,7 +2397,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2397
2397
 
2398
2398
  bool r = c != 0;
2399
2399
  PyObject *result = BOOL_FROM(r);
2400
- Py_INCREF(result);
2400
+ Py_INCREF_IMMORTAL(result);
2401
2401
  return result;
2402
2402
  #else
2403
2403
  bool checked_reverse_op = false;
@@ -2417,7 +2417,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2417
2417
  return result;
2418
2418
  }
2419
2419
 
2420
- Py_DECREF(result);
2420
+ Py_DECREF_IMMORTAL(result);
2421
2421
  }
2422
2422
  }
2423
2423
 
@@ -2432,7 +2432,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2432
2432
  return result;
2433
2433
  }
2434
2434
 
2435
- Py_DECREF(result);
2435
+ Py_DECREF_IMMORTAL(result);
2436
2436
  }
2437
2437
 
2438
2438
  if (checked_reverse_op == false) {
@@ -2447,7 +2447,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2447
2447
  return result;
2448
2448
  }
2449
2449
 
2450
- Py_DECREF(result);
2450
+ Py_DECREF_IMMORTAL(result);
2451
2451
  }
2452
2452
  }
2453
2453
 
@@ -2459,13 +2459,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_UNICODE(PyObject *operand1, PyObject *op
2459
2459
  case Py_EQ: {
2460
2460
  bool r = operand1 == operand2;
2461
2461
  PyObject *result = BOOL_FROM(r);
2462
- Py_INCREF(result);
2462
+ Py_INCREF_IMMORTAL(result);
2463
2463
  return result;
2464
2464
  }
2465
2465
  case Py_NE: {
2466
2466
  bool r = operand1 != operand2;
2467
2467
  PyObject *result = BOOL_FROM(r);
2468
- Py_INCREF(result);
2468
+ Py_INCREF_IMMORTAL(result);
2469
2469
  return result;
2470
2470
  }
2471
2471
  default:
@@ -2515,7 +2515,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2515
2515
  return result;
2516
2516
  }
2517
2517
 
2518
- Py_DECREF(result);
2518
+ Py_DECREF_IMMORTAL(result);
2519
2519
  }
2520
2520
 
2521
2521
  // No rich comparison worked, but maybe compare works.
@@ -2556,7 +2556,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2556
2556
 
2557
2557
  bool r = c != 0;
2558
2558
  PyObject *result = BOOL_FROM(r);
2559
- Py_INCREF(result);
2559
+ Py_INCREF_IMMORTAL(result);
2560
2560
  return result;
2561
2561
  }
2562
2562
  }
@@ -2576,7 +2576,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2576
2576
  return result;
2577
2577
  }
2578
2578
 
2579
- Py_DECREF(result);
2579
+ Py_DECREF_IMMORTAL(result);
2580
2580
  }
2581
2581
  }
2582
2582
 
@@ -2590,7 +2590,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2590
2590
  return result;
2591
2591
  }
2592
2592
 
2593
- Py_DECREF(result);
2593
+ Py_DECREF_IMMORTAL(result);
2594
2594
  }
2595
2595
 
2596
2596
  f = RICHCOMPARE(type2);
@@ -2603,7 +2603,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2603
2603
  return result;
2604
2604
  }
2605
2605
 
2606
- Py_DECREF(result);
2606
+ Py_DECREF_IMMORTAL(result);
2607
2607
  }
2608
2608
 
2609
2609
  int c;
@@ -2691,7 +2691,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2691
2691
 
2692
2692
  bool r = c != 0;
2693
2693
  PyObject *result = BOOL_FROM(r);
2694
- Py_INCREF(result);
2694
+ Py_INCREF_IMMORTAL(result);
2695
2695
  return result;
2696
2696
  #else
2697
2697
  bool checked_reverse_op = false;
@@ -2711,7 +2711,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2711
2711
  return result;
2712
2712
  }
2713
2713
 
2714
- Py_DECREF(result);
2714
+ Py_DECREF_IMMORTAL(result);
2715
2715
  }
2716
2716
  }
2717
2717
 
@@ -2726,7 +2726,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2726
2726
  return result;
2727
2727
  }
2728
2728
 
2729
- Py_DECREF(result);
2729
+ Py_DECREF_IMMORTAL(result);
2730
2730
  }
2731
2731
 
2732
2732
  if (checked_reverse_op == false) {
@@ -2741,7 +2741,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2741
2741
  return result;
2742
2742
  }
2743
2743
 
2744
- Py_DECREF(result);
2744
+ Py_DECREF_IMMORTAL(result);
2745
2745
  }
2746
2746
  }
2747
2747
 
@@ -2753,13 +2753,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_UNICODE_OBJECT(PyObject *operand1, PyObject *op
2753
2753
  case Py_EQ: {
2754
2754
  bool r = operand1 == operand2;
2755
2755
  PyObject *result = BOOL_FROM(r);
2756
- Py_INCREF(result);
2756
+ Py_INCREF_IMMORTAL(result);
2757
2757
  return result;
2758
2758
  }
2759
2759
  case Py_NE: {
2760
2760
  bool r = operand1 != operand2;
2761
2761
  PyObject *result = BOOL_FROM(r);
2762
- Py_INCREF(result);
2762
+ Py_INCREF_IMMORTAL(result);
2763
2763
  return result;
2764
2764
  }
2765
2765
  default:
@@ -2910,7 +2910,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *o
2910
2910
  }
2911
2911
  }
2912
2912
 
2913
- Py_DECREF(result);
2913
+ Py_DECREF_IMMORTAL(result);
2914
2914
  }
2915
2915
 
2916
2916
  // No rich comparison worked, but maybe compare works.
@@ -2979,7 +2979,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *o
2979
2979
  }
2980
2980
  }
2981
2981
 
2982
- Py_DECREF(result);
2982
+ Py_DECREF_IMMORTAL(result);
2983
2983
  }
2984
2984
  }
2985
2985
 
@@ -3001,7 +3001,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *o
3001
3001
  }
3002
3002
  }
3003
3003
 
3004
- Py_DECREF(result);
3004
+ Py_DECREF_IMMORTAL(result);
3005
3005
  }
3006
3006
 
3007
3007
  f = PyUnicode_Type.tp_richcompare;
@@ -3022,7 +3022,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *o
3022
3022
  }
3023
3023
  }
3024
3024
 
3025
- Py_DECREF(result);
3025
+ Py_DECREF_IMMORTAL(result);
3026
3026
  }
3027
3027
 
3028
3028
  int c;
@@ -3138,7 +3138,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *o
3138
3138
  }
3139
3139
  }
3140
3140
 
3141
- Py_DECREF(result);
3141
+ Py_DECREF_IMMORTAL(result);
3142
3142
  }
3143
3143
  }
3144
3144
 
@@ -3161,7 +3161,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *o
3161
3161
  }
3162
3162
  }
3163
3163
 
3164
- Py_DECREF(result);
3164
+ Py_DECREF_IMMORTAL(result);
3165
3165
  }
3166
3166
 
3167
3167
  if (checked_reverse_op == false) {
@@ -3184,7 +3184,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_UNICODE(PyObject *operand1, PyObject *o
3184
3184
  }
3185
3185
  }
3186
3186
 
3187
- Py_DECREF(result);
3187
+ Py_DECREF_IMMORTAL(result);
3188
3188
  }
3189
3189
  }
3190
3190
 
@@ -3260,7 +3260,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *o
3260
3260
  }
3261
3261
  }
3262
3262
 
3263
- Py_DECREF(result);
3263
+ Py_DECREF_IMMORTAL(result);
3264
3264
  }
3265
3265
 
3266
3266
  // No rich comparison worked, but maybe compare works.
@@ -3329,7 +3329,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *o
3329
3329
  }
3330
3330
  }
3331
3331
 
3332
- Py_DECREF(result);
3332
+ Py_DECREF_IMMORTAL(result);
3333
3333
  }
3334
3334
  }
3335
3335
 
@@ -3351,7 +3351,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *o
3351
3351
  }
3352
3352
  }
3353
3353
 
3354
- Py_DECREF(result);
3354
+ Py_DECREF_IMMORTAL(result);
3355
3355
  }
3356
3356
 
3357
3357
  f = RICHCOMPARE(type2);
@@ -3372,7 +3372,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *o
3372
3372
  }
3373
3373
  }
3374
3374
 
3375
- Py_DECREF(result);
3375
+ Py_DECREF_IMMORTAL(result);
3376
3376
  }
3377
3377
 
3378
3378
  int c;
@@ -3488,7 +3488,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *o
3488
3488
  }
3489
3489
  }
3490
3490
 
3491
- Py_DECREF(result);
3491
+ Py_DECREF_IMMORTAL(result);
3492
3492
  }
3493
3493
  }
3494
3494
 
@@ -3511,7 +3511,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *o
3511
3511
  }
3512
3512
  }
3513
3513
 
3514
- Py_DECREF(result);
3514
+ Py_DECREF_IMMORTAL(result);
3515
3515
  }
3516
3516
 
3517
3517
  if (checked_reverse_op == false) {
@@ -3534,7 +3534,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_UNICODE_OBJECT(PyObject *operand1, PyObject *o
3534
3534
  }
3535
3535
  }
3536
3536
 
3537
- Py_DECREF(result);
3537
+ Py_DECREF_IMMORTAL(result);
3538
3538
  }
3539
3539
  }
3540
3540
 
@@ -3584,7 +3584,7 @@ static PyObject *COMPARE_EQ_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *ope
3584
3584
 
3585
3585
  // Convert to target type.
3586
3586
  PyObject *result = BOOL_FROM(r);
3587
- Py_INCREF(result);
3587
+ Py_INCREF_IMMORTAL(result);
3588
3588
  return result;
3589
3589
  }
3590
3590
 
@@ -3596,7 +3596,7 @@ static PyObject *COMPARE_EQ_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *ope
3596
3596
 
3597
3597
  // Convert to target type.
3598
3598
  PyObject *result = BOOL_FROM(r);
3599
- Py_INCREF(result);
3599
+ Py_INCREF_IMMORTAL(result);
3600
3600
  return result;
3601
3601
  } else {
3602
3602
  if ((a->ob_sval[0] == b->ob_sval[0]) && (memcmp(a->ob_sval, b->ob_sval, len_a) == 0)) {
@@ -3604,14 +3604,14 @@ static PyObject *COMPARE_EQ_OBJECT_BYTES_BYTES(PyObject *operand1, PyObject *ope
3604
3604
 
3605
3605
  // Convert to target type.
3606
3606
  PyObject *result = BOOL_FROM(r);
3607
- Py_INCREF(result);
3607
+ Py_INCREF_IMMORTAL(result);
3608
3608
  return result;
3609
3609
  } else {
3610
3610
  bool r = false;
3611
3611
 
3612
3612
  // Convert to target type.
3613
3613
  PyObject *result = BOOL_FROM(r);
3614
- Py_INCREF(result);
3614
+ Py_INCREF_IMMORTAL(result);
3615
3615
  return result;
3616
3616
  }
3617
3617
  }
@@ -3650,7 +3650,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3650
3650
  return result;
3651
3651
  }
3652
3652
 
3653
- Py_DECREF(result);
3653
+ Py_DECREF_IMMORTAL(result);
3654
3654
  }
3655
3655
 
3656
3656
  // No rich comparison worked, but maybe compare works.
@@ -3691,7 +3691,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3691
3691
 
3692
3692
  bool r = c != 0;
3693
3693
  PyObject *result = BOOL_FROM(r);
3694
- Py_INCREF(result);
3694
+ Py_INCREF_IMMORTAL(result);
3695
3695
  return result;
3696
3696
  }
3697
3697
  }
@@ -3711,7 +3711,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3711
3711
  return result;
3712
3712
  }
3713
3713
 
3714
- Py_DECREF(result);
3714
+ Py_DECREF_IMMORTAL(result);
3715
3715
  }
3716
3716
  }
3717
3717
 
@@ -3725,7 +3725,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3725
3725
  return result;
3726
3726
  }
3727
3727
 
3728
- Py_DECREF(result);
3728
+ Py_DECREF_IMMORTAL(result);
3729
3729
  }
3730
3730
 
3731
3731
  f = PyBytes_Type.tp_richcompare;
@@ -3738,7 +3738,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3738
3738
  return result;
3739
3739
  }
3740
3740
 
3741
- Py_DECREF(result);
3741
+ Py_DECREF_IMMORTAL(result);
3742
3742
  }
3743
3743
 
3744
3744
  int c;
@@ -3826,7 +3826,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3826
3826
 
3827
3827
  bool r = c != 0;
3828
3828
  PyObject *result = BOOL_FROM(r);
3829
- Py_INCREF(result);
3829
+ Py_INCREF_IMMORTAL(result);
3830
3830
  return result;
3831
3831
  #else
3832
3832
  bool checked_reverse_op = false;
@@ -3846,7 +3846,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3846
3846
  return result;
3847
3847
  }
3848
3848
 
3849
- Py_DECREF(result);
3849
+ Py_DECREF_IMMORTAL(result);
3850
3850
  }
3851
3851
  }
3852
3852
 
@@ -3861,7 +3861,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3861
3861
  return result;
3862
3862
  }
3863
3863
 
3864
- Py_DECREF(result);
3864
+ Py_DECREF_IMMORTAL(result);
3865
3865
  }
3866
3866
 
3867
3867
  if (checked_reverse_op == false) {
@@ -3876,7 +3876,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3876
3876
  return result;
3877
3877
  }
3878
3878
 
3879
- Py_DECREF(result);
3879
+ Py_DECREF_IMMORTAL(result);
3880
3880
  }
3881
3881
  }
3882
3882
 
@@ -3888,13 +3888,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_BYTES(PyObject *operand1, PyObject *oper
3888
3888
  case Py_EQ: {
3889
3889
  bool r = operand1 == operand2;
3890
3890
  PyObject *result = BOOL_FROM(r);
3891
- Py_INCREF(result);
3891
+ Py_INCREF_IMMORTAL(result);
3892
3892
  return result;
3893
3893
  }
3894
3894
  case Py_NE: {
3895
3895
  bool r = operand1 != operand2;
3896
3896
  PyObject *result = BOOL_FROM(r);
3897
- Py_INCREF(result);
3897
+ Py_INCREF_IMMORTAL(result);
3898
3898
  return result;
3899
3899
  }
3900
3900
  default:
@@ -3944,7 +3944,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
3944
3944
  return result;
3945
3945
  }
3946
3946
 
3947
- Py_DECREF(result);
3947
+ Py_DECREF_IMMORTAL(result);
3948
3948
  }
3949
3949
 
3950
3950
  // No rich comparison worked, but maybe compare works.
@@ -3985,7 +3985,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
3985
3985
 
3986
3986
  bool r = c != 0;
3987
3987
  PyObject *result = BOOL_FROM(r);
3988
- Py_INCREF(result);
3988
+ Py_INCREF_IMMORTAL(result);
3989
3989
  return result;
3990
3990
  }
3991
3991
  }
@@ -4005,7 +4005,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
4005
4005
  return result;
4006
4006
  }
4007
4007
 
4008
- Py_DECREF(result);
4008
+ Py_DECREF_IMMORTAL(result);
4009
4009
  }
4010
4010
  }
4011
4011
 
@@ -4019,7 +4019,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
4019
4019
  return result;
4020
4020
  }
4021
4021
 
4022
- Py_DECREF(result);
4022
+ Py_DECREF_IMMORTAL(result);
4023
4023
  }
4024
4024
 
4025
4025
  f = RICHCOMPARE(type2);
@@ -4032,7 +4032,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
4032
4032
  return result;
4033
4033
  }
4034
4034
 
4035
- Py_DECREF(result);
4035
+ Py_DECREF_IMMORTAL(result);
4036
4036
  }
4037
4037
 
4038
4038
  int c;
@@ -4120,7 +4120,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
4120
4120
 
4121
4121
  bool r = c != 0;
4122
4122
  PyObject *result = BOOL_FROM(r);
4123
- Py_INCREF(result);
4123
+ Py_INCREF_IMMORTAL(result);
4124
4124
  return result;
4125
4125
  #else
4126
4126
  bool checked_reverse_op = false;
@@ -4140,7 +4140,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
4140
4140
  return result;
4141
4141
  }
4142
4142
 
4143
- Py_DECREF(result);
4143
+ Py_DECREF_IMMORTAL(result);
4144
4144
  }
4145
4145
  }
4146
4146
 
@@ -4155,7 +4155,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
4155
4155
  return result;
4156
4156
  }
4157
4157
 
4158
- Py_DECREF(result);
4158
+ Py_DECREF_IMMORTAL(result);
4159
4159
  }
4160
4160
 
4161
4161
  if (checked_reverse_op == false) {
@@ -4170,7 +4170,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
4170
4170
  return result;
4171
4171
  }
4172
4172
 
4173
- Py_DECREF(result);
4173
+ Py_DECREF_IMMORTAL(result);
4174
4174
  }
4175
4175
  }
4176
4176
 
@@ -4182,13 +4182,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_BYTES_OBJECT(PyObject *operand1, PyObject *oper
4182
4182
  case Py_EQ: {
4183
4183
  bool r = operand1 == operand2;
4184
4184
  PyObject *result = BOOL_FROM(r);
4185
- Py_INCREF(result);
4185
+ Py_INCREF_IMMORTAL(result);
4186
4186
  return result;
4187
4187
  }
4188
4188
  case Py_NE: {
4189
4189
  bool r = operand1 != operand2;
4190
4190
  PyObject *result = BOOL_FROM(r);
4191
- Py_INCREF(result);
4191
+ Py_INCREF_IMMORTAL(result);
4192
4192
  return result;
4193
4193
  }
4194
4194
  default:
@@ -4309,7 +4309,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *ope
4309
4309
  }
4310
4310
  }
4311
4311
 
4312
- Py_DECREF(result);
4312
+ Py_DECREF_IMMORTAL(result);
4313
4313
  }
4314
4314
 
4315
4315
  // No rich comparison worked, but maybe compare works.
@@ -4378,7 +4378,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *ope
4378
4378
  }
4379
4379
  }
4380
4380
 
4381
- Py_DECREF(result);
4381
+ Py_DECREF_IMMORTAL(result);
4382
4382
  }
4383
4383
  }
4384
4384
 
@@ -4400,7 +4400,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *ope
4400
4400
  }
4401
4401
  }
4402
4402
 
4403
- Py_DECREF(result);
4403
+ Py_DECREF_IMMORTAL(result);
4404
4404
  }
4405
4405
 
4406
4406
  f = PyBytes_Type.tp_richcompare;
@@ -4421,7 +4421,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *ope
4421
4421
  }
4422
4422
  }
4423
4423
 
4424
- Py_DECREF(result);
4424
+ Py_DECREF_IMMORTAL(result);
4425
4425
  }
4426
4426
 
4427
4427
  int c;
@@ -4537,7 +4537,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *ope
4537
4537
  }
4538
4538
  }
4539
4539
 
4540
- Py_DECREF(result);
4540
+ Py_DECREF_IMMORTAL(result);
4541
4541
  }
4542
4542
  }
4543
4543
 
@@ -4560,7 +4560,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *ope
4560
4560
  }
4561
4561
  }
4562
4562
 
4563
- Py_DECREF(result);
4563
+ Py_DECREF_IMMORTAL(result);
4564
4564
  }
4565
4565
 
4566
4566
  if (checked_reverse_op == false) {
@@ -4583,7 +4583,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_BYTES(PyObject *operand1, PyObject *ope
4583
4583
  }
4584
4584
  }
4585
4585
 
4586
- Py_DECREF(result);
4586
+ Py_DECREF_IMMORTAL(result);
4587
4587
  }
4588
4588
  }
4589
4589
 
@@ -4659,7 +4659,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *ope
4659
4659
  }
4660
4660
  }
4661
4661
 
4662
- Py_DECREF(result);
4662
+ Py_DECREF_IMMORTAL(result);
4663
4663
  }
4664
4664
 
4665
4665
  // No rich comparison worked, but maybe compare works.
@@ -4728,7 +4728,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *ope
4728
4728
  }
4729
4729
  }
4730
4730
 
4731
- Py_DECREF(result);
4731
+ Py_DECREF_IMMORTAL(result);
4732
4732
  }
4733
4733
  }
4734
4734
 
@@ -4750,7 +4750,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *ope
4750
4750
  }
4751
4751
  }
4752
4752
 
4753
- Py_DECREF(result);
4753
+ Py_DECREF_IMMORTAL(result);
4754
4754
  }
4755
4755
 
4756
4756
  f = RICHCOMPARE(type2);
@@ -4771,7 +4771,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *ope
4771
4771
  }
4772
4772
  }
4773
4773
 
4774
- Py_DECREF(result);
4774
+ Py_DECREF_IMMORTAL(result);
4775
4775
  }
4776
4776
 
4777
4777
  int c;
@@ -4887,7 +4887,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *ope
4887
4887
  }
4888
4888
  }
4889
4889
 
4890
- Py_DECREF(result);
4890
+ Py_DECREF_IMMORTAL(result);
4891
4891
  }
4892
4892
  }
4893
4893
 
@@ -4910,7 +4910,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *ope
4910
4910
  }
4911
4911
  }
4912
4912
 
4913
- Py_DECREF(result);
4913
+ Py_DECREF_IMMORTAL(result);
4914
4914
  }
4915
4915
 
4916
4916
  if (checked_reverse_op == false) {
@@ -4933,7 +4933,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_BYTES_OBJECT(PyObject *operand1, PyObject *ope
4933
4933
  }
4934
4934
  }
4935
4935
 
4936
- Py_DECREF(result);
4936
+ Py_DECREF_IMMORTAL(result);
4937
4937
  }
4938
4938
  }
4939
4939
 
@@ -5001,7 +5001,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5001
5001
  return result;
5002
5002
  }
5003
5003
 
5004
- Py_DECREF(result);
5004
+ Py_DECREF_IMMORTAL(result);
5005
5005
  }
5006
5006
 
5007
5007
  // No rich comparison worked, but maybe compare works.
@@ -5042,7 +5042,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5042
5042
 
5043
5043
  bool r = c != 0;
5044
5044
  PyObject *result = BOOL_FROM(r);
5045
- Py_INCREF(result);
5045
+ Py_INCREF_IMMORTAL(result);
5046
5046
  return result;
5047
5047
  }
5048
5048
  }
@@ -5062,7 +5062,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5062
5062
  return result;
5063
5063
  }
5064
5064
 
5065
- Py_DECREF(result);
5065
+ Py_DECREF_IMMORTAL(result);
5066
5066
  }
5067
5067
  }
5068
5068
 
@@ -5076,7 +5076,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5076
5076
  return result;
5077
5077
  }
5078
5078
 
5079
- Py_DECREF(result);
5079
+ Py_DECREF_IMMORTAL(result);
5080
5080
  }
5081
5081
 
5082
5082
  f = NULL;
@@ -5089,7 +5089,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5089
5089
  return result;
5090
5090
  }
5091
5091
 
5092
- Py_DECREF(result);
5092
+ Py_DECREF_IMMORTAL(result);
5093
5093
  }
5094
5094
 
5095
5095
  int c;
@@ -5177,7 +5177,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5177
5177
 
5178
5178
  bool r = c != 0;
5179
5179
  PyObject *result = BOOL_FROM(r);
5180
- Py_INCREF(result);
5180
+ Py_INCREF_IMMORTAL(result);
5181
5181
  return result;
5182
5182
  #else
5183
5183
  bool checked_reverse_op = false;
@@ -5197,7 +5197,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5197
5197
  return result;
5198
5198
  }
5199
5199
 
5200
- Py_DECREF(result);
5200
+ Py_DECREF_IMMORTAL(result);
5201
5201
  }
5202
5202
  }
5203
5203
 
@@ -5212,7 +5212,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5212
5212
  return result;
5213
5213
  }
5214
5214
 
5215
- Py_DECREF(result);
5215
+ Py_DECREF_IMMORTAL(result);
5216
5216
  }
5217
5217
 
5218
5218
  if (checked_reverse_op == false) {
@@ -5227,7 +5227,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5227
5227
  return result;
5228
5228
  }
5229
5229
 
5230
- Py_DECREF(result);
5230
+ Py_DECREF_IMMORTAL(result);
5231
5231
  }
5232
5232
  }
5233
5233
 
@@ -5239,13 +5239,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_INT(PyObject *operand1, PyObject *operan
5239
5239
  case Py_EQ: {
5240
5240
  bool r = operand1 == operand2;
5241
5241
  PyObject *result = BOOL_FROM(r);
5242
- Py_INCREF(result);
5242
+ Py_INCREF_IMMORTAL(result);
5243
5243
  return result;
5244
5244
  }
5245
5245
  case Py_NE: {
5246
5246
  bool r = operand1 != operand2;
5247
5247
  PyObject *result = BOOL_FROM(r);
5248
- Py_INCREF(result);
5248
+ Py_INCREF_IMMORTAL(result);
5249
5249
  return result;
5250
5250
  }
5251
5251
  default:
@@ -5295,7 +5295,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5295
5295
  return result;
5296
5296
  }
5297
5297
 
5298
- Py_DECREF(result);
5298
+ Py_DECREF_IMMORTAL(result);
5299
5299
  }
5300
5300
 
5301
5301
  // No rich comparison worked, but maybe compare works.
@@ -5336,7 +5336,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5336
5336
 
5337
5337
  bool r = c != 0;
5338
5338
  PyObject *result = BOOL_FROM(r);
5339
- Py_INCREF(result);
5339
+ Py_INCREF_IMMORTAL(result);
5340
5340
  return result;
5341
5341
  }
5342
5342
  }
@@ -5356,7 +5356,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5356
5356
  return result;
5357
5357
  }
5358
5358
 
5359
- Py_DECREF(result);
5359
+ Py_DECREF_IMMORTAL(result);
5360
5360
  }
5361
5361
  }
5362
5362
 
@@ -5370,7 +5370,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5370
5370
  return result;
5371
5371
  }
5372
5372
 
5373
- Py_DECREF(result);
5373
+ Py_DECREF_IMMORTAL(result);
5374
5374
  }
5375
5375
 
5376
5376
  f = RICHCOMPARE(type2);
@@ -5383,7 +5383,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5383
5383
  return result;
5384
5384
  }
5385
5385
 
5386
- Py_DECREF(result);
5386
+ Py_DECREF_IMMORTAL(result);
5387
5387
  }
5388
5388
 
5389
5389
  int c;
@@ -5471,7 +5471,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5471
5471
 
5472
5472
  bool r = c != 0;
5473
5473
  PyObject *result = BOOL_FROM(r);
5474
- Py_INCREF(result);
5474
+ Py_INCREF_IMMORTAL(result);
5475
5475
  return result;
5476
5476
  #else
5477
5477
  bool checked_reverse_op = false;
@@ -5491,7 +5491,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5491
5491
  return result;
5492
5492
  }
5493
5493
 
5494
- Py_DECREF(result);
5494
+ Py_DECREF_IMMORTAL(result);
5495
5495
  }
5496
5496
  }
5497
5497
 
@@ -5506,7 +5506,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5506
5506
  return result;
5507
5507
  }
5508
5508
 
5509
- Py_DECREF(result);
5509
+ Py_DECREF_IMMORTAL(result);
5510
5510
  }
5511
5511
 
5512
5512
  if (checked_reverse_op == false) {
@@ -5521,7 +5521,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5521
5521
  return result;
5522
5522
  }
5523
5523
 
5524
- Py_DECREF(result);
5524
+ Py_DECREF_IMMORTAL(result);
5525
5525
  }
5526
5526
  }
5527
5527
 
@@ -5533,13 +5533,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_INT_OBJECT(PyObject *operand1, PyObject *operan
5533
5533
  case Py_EQ: {
5534
5534
  bool r = operand1 == operand2;
5535
5535
  PyObject *result = BOOL_FROM(r);
5536
- Py_INCREF(result);
5536
+ Py_INCREF_IMMORTAL(result);
5537
5537
  return result;
5538
5538
  }
5539
5539
  case Py_NE: {
5540
5540
  bool r = operand1 != operand2;
5541
5541
  PyObject *result = BOOL_FROM(r);
5542
- Py_INCREF(result);
5542
+ Py_INCREF_IMMORTAL(result);
5543
5543
  return result;
5544
5544
  }
5545
5545
  default:
@@ -5613,7 +5613,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *opera
5613
5613
  }
5614
5614
  }
5615
5615
 
5616
- Py_DECREF(result);
5616
+ Py_DECREF_IMMORTAL(result);
5617
5617
  }
5618
5618
 
5619
5619
  // No rich comparison worked, but maybe compare works.
@@ -5682,7 +5682,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *opera
5682
5682
  }
5683
5683
  }
5684
5684
 
5685
- Py_DECREF(result);
5685
+ Py_DECREF_IMMORTAL(result);
5686
5686
  }
5687
5687
  }
5688
5688
 
@@ -5704,7 +5704,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *opera
5704
5704
  }
5705
5705
  }
5706
5706
 
5707
- Py_DECREF(result);
5707
+ Py_DECREF_IMMORTAL(result);
5708
5708
  }
5709
5709
 
5710
5710
  f = NULL;
@@ -5725,7 +5725,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *opera
5725
5725
  }
5726
5726
  }
5727
5727
 
5728
- Py_DECREF(result);
5728
+ Py_DECREF_IMMORTAL(result);
5729
5729
  }
5730
5730
 
5731
5731
  int c;
@@ -5841,7 +5841,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *opera
5841
5841
  }
5842
5842
  }
5843
5843
 
5844
- Py_DECREF(result);
5844
+ Py_DECREF_IMMORTAL(result);
5845
5845
  }
5846
5846
  }
5847
5847
 
@@ -5864,7 +5864,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *opera
5864
5864
  }
5865
5865
  }
5866
5866
 
5867
- Py_DECREF(result);
5867
+ Py_DECREF_IMMORTAL(result);
5868
5868
  }
5869
5869
 
5870
5870
  if (checked_reverse_op == false) {
@@ -5887,7 +5887,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_INT(PyObject *operand1, PyObject *opera
5887
5887
  }
5888
5888
  }
5889
5889
 
5890
- Py_DECREF(result);
5890
+ Py_DECREF_IMMORTAL(result);
5891
5891
  }
5892
5892
  }
5893
5893
 
@@ -5963,7 +5963,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *opera
5963
5963
  }
5964
5964
  }
5965
5965
 
5966
- Py_DECREF(result);
5966
+ Py_DECREF_IMMORTAL(result);
5967
5967
  }
5968
5968
 
5969
5969
  // No rich comparison worked, but maybe compare works.
@@ -6032,7 +6032,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *opera
6032
6032
  }
6033
6033
  }
6034
6034
 
6035
- Py_DECREF(result);
6035
+ Py_DECREF_IMMORTAL(result);
6036
6036
  }
6037
6037
  }
6038
6038
 
@@ -6054,7 +6054,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *opera
6054
6054
  }
6055
6055
  }
6056
6056
 
6057
- Py_DECREF(result);
6057
+ Py_DECREF_IMMORTAL(result);
6058
6058
  }
6059
6059
 
6060
6060
  f = RICHCOMPARE(type2);
@@ -6075,7 +6075,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *opera
6075
6075
  }
6076
6076
  }
6077
6077
 
6078
- Py_DECREF(result);
6078
+ Py_DECREF_IMMORTAL(result);
6079
6079
  }
6080
6080
 
6081
6081
  int c;
@@ -6191,7 +6191,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *opera
6191
6191
  }
6192
6192
  }
6193
6193
 
6194
- Py_DECREF(result);
6194
+ Py_DECREF_IMMORTAL(result);
6195
6195
  }
6196
6196
  }
6197
6197
 
@@ -6214,7 +6214,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *opera
6214
6214
  }
6215
6215
  }
6216
6216
 
6217
- Py_DECREF(result);
6217
+ Py_DECREF_IMMORTAL(result);
6218
6218
  }
6219
6219
 
6220
6220
  if (checked_reverse_op == false) {
@@ -6237,7 +6237,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_INT_OBJECT(PyObject *operand1, PyObject *opera
6237
6237
  }
6238
6238
  }
6239
6239
 
6240
- Py_DECREF(result);
6240
+ Py_DECREF_IMMORTAL(result);
6241
6241
  }
6242
6242
  }
6243
6243
 
@@ -6302,7 +6302,7 @@ static PyObject *COMPARE_EQ_OBJECT_LONG_LONG(PyObject *operand1, PyObject *opera
6302
6302
 
6303
6303
  // Convert to target type.
6304
6304
  PyObject *result = BOOL_FROM(r);
6305
- Py_INCREF(result);
6305
+ Py_INCREF_IMMORTAL(result);
6306
6306
  return result;
6307
6307
  }
6308
6308
  /* Code referring to "OBJECT" corresponds to any Python object and "LONG" to Python2 'long', Python3 'int'. */
@@ -6339,7 +6339,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6339
6339
  return result;
6340
6340
  }
6341
6341
 
6342
- Py_DECREF(result);
6342
+ Py_DECREF_IMMORTAL(result);
6343
6343
  }
6344
6344
 
6345
6345
  // No rich comparison worked, but maybe compare works.
@@ -6380,7 +6380,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6380
6380
 
6381
6381
  bool r = c != 0;
6382
6382
  PyObject *result = BOOL_FROM(r);
6383
- Py_INCREF(result);
6383
+ Py_INCREF_IMMORTAL(result);
6384
6384
  return result;
6385
6385
  }
6386
6386
  }
@@ -6400,7 +6400,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6400
6400
  return result;
6401
6401
  }
6402
6402
 
6403
- Py_DECREF(result);
6403
+ Py_DECREF_IMMORTAL(result);
6404
6404
  }
6405
6405
  }
6406
6406
 
@@ -6414,7 +6414,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6414
6414
  return result;
6415
6415
  }
6416
6416
 
6417
- Py_DECREF(result);
6417
+ Py_DECREF_IMMORTAL(result);
6418
6418
  }
6419
6419
 
6420
6420
  f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
@@ -6427,7 +6427,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6427
6427
  return result;
6428
6428
  }
6429
6429
 
6430
- Py_DECREF(result);
6430
+ Py_DECREF_IMMORTAL(result);
6431
6431
  }
6432
6432
 
6433
6433
  int c;
@@ -6515,7 +6515,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6515
6515
 
6516
6516
  bool r = c != 0;
6517
6517
  PyObject *result = BOOL_FROM(r);
6518
- Py_INCREF(result);
6518
+ Py_INCREF_IMMORTAL(result);
6519
6519
  return result;
6520
6520
  #else
6521
6521
  bool checked_reverse_op = false;
@@ -6535,7 +6535,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6535
6535
  return result;
6536
6536
  }
6537
6537
 
6538
- Py_DECREF(result);
6538
+ Py_DECREF_IMMORTAL(result);
6539
6539
  }
6540
6540
  }
6541
6541
 
@@ -6550,7 +6550,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6550
6550
  return result;
6551
6551
  }
6552
6552
 
6553
- Py_DECREF(result);
6553
+ Py_DECREF_IMMORTAL(result);
6554
6554
  }
6555
6555
 
6556
6556
  if (checked_reverse_op == false) {
@@ -6565,7 +6565,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6565
6565
  return result;
6566
6566
  }
6567
6567
 
6568
- Py_DECREF(result);
6568
+ Py_DECREF_IMMORTAL(result);
6569
6569
  }
6570
6570
  }
6571
6571
 
@@ -6577,13 +6577,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LONG(PyObject *operand1, PyObject *opera
6577
6577
  case Py_EQ: {
6578
6578
  bool r = operand1 == operand2;
6579
6579
  PyObject *result = BOOL_FROM(r);
6580
- Py_INCREF(result);
6580
+ Py_INCREF_IMMORTAL(result);
6581
6581
  return result;
6582
6582
  }
6583
6583
  case Py_NE: {
6584
6584
  bool r = operand1 != operand2;
6585
6585
  PyObject *result = BOOL_FROM(r);
6586
- Py_INCREF(result);
6586
+ Py_INCREF_IMMORTAL(result);
6587
6587
  return result;
6588
6588
  }
6589
6589
  default:
@@ -6633,7 +6633,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6633
6633
  return result;
6634
6634
  }
6635
6635
 
6636
- Py_DECREF(result);
6636
+ Py_DECREF_IMMORTAL(result);
6637
6637
  }
6638
6638
 
6639
6639
  // No rich comparison worked, but maybe compare works.
@@ -6674,7 +6674,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6674
6674
 
6675
6675
  bool r = c != 0;
6676
6676
  PyObject *result = BOOL_FROM(r);
6677
- Py_INCREF(result);
6677
+ Py_INCREF_IMMORTAL(result);
6678
6678
  return result;
6679
6679
  }
6680
6680
  }
@@ -6694,7 +6694,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6694
6694
  return result;
6695
6695
  }
6696
6696
 
6697
- Py_DECREF(result);
6697
+ Py_DECREF_IMMORTAL(result);
6698
6698
  }
6699
6699
  }
6700
6700
 
@@ -6708,7 +6708,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6708
6708
  return result;
6709
6709
  }
6710
6710
 
6711
- Py_DECREF(result);
6711
+ Py_DECREF_IMMORTAL(result);
6712
6712
  }
6713
6713
 
6714
6714
  f = RICHCOMPARE(type2);
@@ -6721,7 +6721,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6721
6721
  return result;
6722
6722
  }
6723
6723
 
6724
- Py_DECREF(result);
6724
+ Py_DECREF_IMMORTAL(result);
6725
6725
  }
6726
6726
 
6727
6727
  int c;
@@ -6809,7 +6809,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6809
6809
 
6810
6810
  bool r = c != 0;
6811
6811
  PyObject *result = BOOL_FROM(r);
6812
- Py_INCREF(result);
6812
+ Py_INCREF_IMMORTAL(result);
6813
6813
  return result;
6814
6814
  #else
6815
6815
  bool checked_reverse_op = false;
@@ -6829,7 +6829,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6829
6829
  return result;
6830
6830
  }
6831
6831
 
6832
- Py_DECREF(result);
6832
+ Py_DECREF_IMMORTAL(result);
6833
6833
  }
6834
6834
  }
6835
6835
 
@@ -6844,7 +6844,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6844
6844
  return result;
6845
6845
  }
6846
6846
 
6847
- Py_DECREF(result);
6847
+ Py_DECREF_IMMORTAL(result);
6848
6848
  }
6849
6849
 
6850
6850
  if (checked_reverse_op == false) {
@@ -6859,7 +6859,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6859
6859
  return result;
6860
6860
  }
6861
6861
 
6862
- Py_DECREF(result);
6862
+ Py_DECREF_IMMORTAL(result);
6863
6863
  }
6864
6864
  }
6865
6865
 
@@ -6871,13 +6871,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LONG_OBJECT(PyObject *operand1, PyObject *opera
6871
6871
  case Py_EQ: {
6872
6872
  bool r = operand1 == operand2;
6873
6873
  PyObject *result = BOOL_FROM(r);
6874
- Py_INCREF(result);
6874
+ Py_INCREF_IMMORTAL(result);
6875
6875
  return result;
6876
6876
  }
6877
6877
  case Py_NE: {
6878
6878
  bool r = operand1 != operand2;
6879
6879
  PyObject *result = BOOL_FROM(r);
6880
- Py_INCREF(result);
6880
+ Py_INCREF_IMMORTAL(result);
6881
6881
  return result;
6882
6882
  }
6883
6883
  default:
@@ -6982,7 +6982,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *oper
6982
6982
  }
6983
6983
  }
6984
6984
 
6985
- Py_DECREF(result);
6985
+ Py_DECREF_IMMORTAL(result);
6986
6986
  }
6987
6987
 
6988
6988
  // No rich comparison worked, but maybe compare works.
@@ -7051,7 +7051,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *oper
7051
7051
  }
7052
7052
  }
7053
7053
 
7054
- Py_DECREF(result);
7054
+ Py_DECREF_IMMORTAL(result);
7055
7055
  }
7056
7056
  }
7057
7057
 
@@ -7073,7 +7073,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *oper
7073
7073
  }
7074
7074
  }
7075
7075
 
7076
- Py_DECREF(result);
7076
+ Py_DECREF_IMMORTAL(result);
7077
7077
  }
7078
7078
 
7079
7079
  f = (PYTHON_VERSION < 0x300 ? NULL : PyLong_Type.tp_richcompare);
@@ -7094,7 +7094,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *oper
7094
7094
  }
7095
7095
  }
7096
7096
 
7097
- Py_DECREF(result);
7097
+ Py_DECREF_IMMORTAL(result);
7098
7098
  }
7099
7099
 
7100
7100
  int c;
@@ -7210,7 +7210,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *oper
7210
7210
  }
7211
7211
  }
7212
7212
 
7213
- Py_DECREF(result);
7213
+ Py_DECREF_IMMORTAL(result);
7214
7214
  }
7215
7215
  }
7216
7216
 
@@ -7233,7 +7233,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *oper
7233
7233
  }
7234
7234
  }
7235
7235
 
7236
- Py_DECREF(result);
7236
+ Py_DECREF_IMMORTAL(result);
7237
7237
  }
7238
7238
 
7239
7239
  if (checked_reverse_op == false) {
@@ -7256,7 +7256,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LONG(PyObject *operand1, PyObject *oper
7256
7256
  }
7257
7257
  }
7258
7258
 
7259
- Py_DECREF(result);
7259
+ Py_DECREF_IMMORTAL(result);
7260
7260
  }
7261
7261
  }
7262
7262
 
@@ -7332,7 +7332,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *oper
7332
7332
  }
7333
7333
  }
7334
7334
 
7335
- Py_DECREF(result);
7335
+ Py_DECREF_IMMORTAL(result);
7336
7336
  }
7337
7337
 
7338
7338
  // No rich comparison worked, but maybe compare works.
@@ -7401,7 +7401,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *oper
7401
7401
  }
7402
7402
  }
7403
7403
 
7404
- Py_DECREF(result);
7404
+ Py_DECREF_IMMORTAL(result);
7405
7405
  }
7406
7406
  }
7407
7407
 
@@ -7423,7 +7423,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *oper
7423
7423
  }
7424
7424
  }
7425
7425
 
7426
- Py_DECREF(result);
7426
+ Py_DECREF_IMMORTAL(result);
7427
7427
  }
7428
7428
 
7429
7429
  f = RICHCOMPARE(type2);
@@ -7444,7 +7444,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *oper
7444
7444
  }
7445
7445
  }
7446
7446
 
7447
- Py_DECREF(result);
7447
+ Py_DECREF_IMMORTAL(result);
7448
7448
  }
7449
7449
 
7450
7450
  int c;
@@ -7560,7 +7560,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *oper
7560
7560
  }
7561
7561
  }
7562
7562
 
7563
- Py_DECREF(result);
7563
+ Py_DECREF_IMMORTAL(result);
7564
7564
  }
7565
7565
  }
7566
7566
 
@@ -7583,7 +7583,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *oper
7583
7583
  }
7584
7584
  }
7585
7585
 
7586
- Py_DECREF(result);
7586
+ Py_DECREF_IMMORTAL(result);
7587
7587
  }
7588
7588
 
7589
7589
  if (checked_reverse_op == false) {
@@ -7606,7 +7606,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LONG_OBJECT(PyObject *operand1, PyObject *oper
7606
7606
  }
7607
7607
  }
7608
7608
 
7609
- Py_DECREF(result);
7609
+ Py_DECREF_IMMORTAL(result);
7610
7610
  }
7611
7611
  }
7612
7612
 
@@ -7653,7 +7653,7 @@ static PyObject *COMPARE_EQ_OBJECT_FLOAT_FLOAT(PyObject *operand1, PyObject *ope
7653
7653
 
7654
7654
  // Convert to target type.
7655
7655
  PyObject *result = BOOL_FROM(r);
7656
- Py_INCREF(result);
7656
+ Py_INCREF_IMMORTAL(result);
7657
7657
  return result;
7658
7658
  }
7659
7659
  /* Code referring to "OBJECT" corresponds to any Python object and "FLOAT" to Python 'float'. */
@@ -7690,7 +7690,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7690
7690
  return result;
7691
7691
  }
7692
7692
 
7693
- Py_DECREF(result);
7693
+ Py_DECREF_IMMORTAL(result);
7694
7694
  }
7695
7695
 
7696
7696
  // No rich comparison worked, but maybe compare works.
@@ -7731,7 +7731,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7731
7731
 
7732
7732
  bool r = c != 0;
7733
7733
  PyObject *result = BOOL_FROM(r);
7734
- Py_INCREF(result);
7734
+ Py_INCREF_IMMORTAL(result);
7735
7735
  return result;
7736
7736
  }
7737
7737
  }
@@ -7751,7 +7751,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7751
7751
  return result;
7752
7752
  }
7753
7753
 
7754
- Py_DECREF(result);
7754
+ Py_DECREF_IMMORTAL(result);
7755
7755
  }
7756
7756
  }
7757
7757
 
@@ -7765,7 +7765,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7765
7765
  return result;
7766
7766
  }
7767
7767
 
7768
- Py_DECREF(result);
7768
+ Py_DECREF_IMMORTAL(result);
7769
7769
  }
7770
7770
 
7771
7771
  f = PyFloat_Type.tp_richcompare;
@@ -7778,7 +7778,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7778
7778
  return result;
7779
7779
  }
7780
7780
 
7781
- Py_DECREF(result);
7781
+ Py_DECREF_IMMORTAL(result);
7782
7782
  }
7783
7783
 
7784
7784
  int c;
@@ -7866,7 +7866,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7866
7866
 
7867
7867
  bool r = c != 0;
7868
7868
  PyObject *result = BOOL_FROM(r);
7869
- Py_INCREF(result);
7869
+ Py_INCREF_IMMORTAL(result);
7870
7870
  return result;
7871
7871
  #else
7872
7872
  bool checked_reverse_op = false;
@@ -7886,7 +7886,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7886
7886
  return result;
7887
7887
  }
7888
7888
 
7889
- Py_DECREF(result);
7889
+ Py_DECREF_IMMORTAL(result);
7890
7890
  }
7891
7891
  }
7892
7892
 
@@ -7901,7 +7901,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7901
7901
  return result;
7902
7902
  }
7903
7903
 
7904
- Py_DECREF(result);
7904
+ Py_DECREF_IMMORTAL(result);
7905
7905
  }
7906
7906
 
7907
7907
  if (checked_reverse_op == false) {
@@ -7916,7 +7916,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7916
7916
  return result;
7917
7917
  }
7918
7918
 
7919
- Py_DECREF(result);
7919
+ Py_DECREF_IMMORTAL(result);
7920
7920
  }
7921
7921
  }
7922
7922
 
@@ -7928,13 +7928,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_FLOAT(PyObject *operand1, PyObject *oper
7928
7928
  case Py_EQ: {
7929
7929
  bool r = operand1 == operand2;
7930
7930
  PyObject *result = BOOL_FROM(r);
7931
- Py_INCREF(result);
7931
+ Py_INCREF_IMMORTAL(result);
7932
7932
  return result;
7933
7933
  }
7934
7934
  case Py_NE: {
7935
7935
  bool r = operand1 != operand2;
7936
7936
  PyObject *result = BOOL_FROM(r);
7937
- Py_INCREF(result);
7937
+ Py_INCREF_IMMORTAL(result);
7938
7938
  return result;
7939
7939
  }
7940
7940
  default:
@@ -7982,7 +7982,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
7982
7982
  return result;
7983
7983
  }
7984
7984
 
7985
- Py_DECREF(result);
7985
+ Py_DECREF_IMMORTAL(result);
7986
7986
  }
7987
7987
 
7988
7988
  // No rich comparison worked, but maybe compare works.
@@ -8023,7 +8023,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8023
8023
 
8024
8024
  bool r = c != 0;
8025
8025
  PyObject *result = BOOL_FROM(r);
8026
- Py_INCREF(result);
8026
+ Py_INCREF_IMMORTAL(result);
8027
8027
  return result;
8028
8028
  }
8029
8029
  }
@@ -8043,7 +8043,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8043
8043
  return result;
8044
8044
  }
8045
8045
 
8046
- Py_DECREF(result);
8046
+ Py_DECREF_IMMORTAL(result);
8047
8047
  }
8048
8048
  }
8049
8049
 
@@ -8057,7 +8057,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8057
8057
  return result;
8058
8058
  }
8059
8059
 
8060
- Py_DECREF(result);
8060
+ Py_DECREF_IMMORTAL(result);
8061
8061
  }
8062
8062
 
8063
8063
  f = RICHCOMPARE(type2);
@@ -8070,7 +8070,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8070
8070
  return result;
8071
8071
  }
8072
8072
 
8073
- Py_DECREF(result);
8073
+ Py_DECREF_IMMORTAL(result);
8074
8074
  }
8075
8075
 
8076
8076
  int c;
@@ -8158,7 +8158,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8158
8158
 
8159
8159
  bool r = c != 0;
8160
8160
  PyObject *result = BOOL_FROM(r);
8161
- Py_INCREF(result);
8161
+ Py_INCREF_IMMORTAL(result);
8162
8162
  return result;
8163
8163
  #else
8164
8164
  bool checked_reverse_op = false;
@@ -8178,7 +8178,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8178
8178
  return result;
8179
8179
  }
8180
8180
 
8181
- Py_DECREF(result);
8181
+ Py_DECREF_IMMORTAL(result);
8182
8182
  }
8183
8183
  }
8184
8184
 
@@ -8193,7 +8193,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8193
8193
  return result;
8194
8194
  }
8195
8195
 
8196
- Py_DECREF(result);
8196
+ Py_DECREF_IMMORTAL(result);
8197
8197
  }
8198
8198
 
8199
8199
  if (checked_reverse_op == false) {
@@ -8208,7 +8208,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8208
8208
  return result;
8209
8209
  }
8210
8210
 
8211
- Py_DECREF(result);
8211
+ Py_DECREF_IMMORTAL(result);
8212
8212
  }
8213
8213
  }
8214
8214
 
@@ -8220,13 +8220,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_FLOAT_OBJECT(PyObject *operand1, PyObject *oper
8220
8220
  case Py_EQ: {
8221
8221
  bool r = operand1 == operand2;
8222
8222
  PyObject *result = BOOL_FROM(r);
8223
- Py_INCREF(result);
8223
+ Py_INCREF_IMMORTAL(result);
8224
8224
  return result;
8225
8225
  }
8226
8226
  case Py_NE: {
8227
8227
  bool r = operand1 != operand2;
8228
8228
  PyObject *result = BOOL_FROM(r);
8229
- Py_INCREF(result);
8229
+ Py_INCREF_IMMORTAL(result);
8230
8230
  return result;
8231
8231
  }
8232
8232
  default:
@@ -8310,7 +8310,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *ope
8310
8310
  }
8311
8311
  }
8312
8312
 
8313
- Py_DECREF(result);
8313
+ Py_DECREF_IMMORTAL(result);
8314
8314
  }
8315
8315
 
8316
8316
  // No rich comparison worked, but maybe compare works.
@@ -8379,7 +8379,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *ope
8379
8379
  }
8380
8380
  }
8381
8381
 
8382
- Py_DECREF(result);
8382
+ Py_DECREF_IMMORTAL(result);
8383
8383
  }
8384
8384
  }
8385
8385
 
@@ -8401,7 +8401,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *ope
8401
8401
  }
8402
8402
  }
8403
8403
 
8404
- Py_DECREF(result);
8404
+ Py_DECREF_IMMORTAL(result);
8405
8405
  }
8406
8406
 
8407
8407
  f = PyFloat_Type.tp_richcompare;
@@ -8422,7 +8422,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *ope
8422
8422
  }
8423
8423
  }
8424
8424
 
8425
- Py_DECREF(result);
8425
+ Py_DECREF_IMMORTAL(result);
8426
8426
  }
8427
8427
 
8428
8428
  int c;
@@ -8538,7 +8538,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *ope
8538
8538
  }
8539
8539
  }
8540
8540
 
8541
- Py_DECREF(result);
8541
+ Py_DECREF_IMMORTAL(result);
8542
8542
  }
8543
8543
  }
8544
8544
 
@@ -8561,7 +8561,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *ope
8561
8561
  }
8562
8562
  }
8563
8563
 
8564
- Py_DECREF(result);
8564
+ Py_DECREF_IMMORTAL(result);
8565
8565
  }
8566
8566
 
8567
8567
  if (checked_reverse_op == false) {
@@ -8584,7 +8584,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_FLOAT(PyObject *operand1, PyObject *ope
8584
8584
  }
8585
8585
  }
8586
8586
 
8587
- Py_DECREF(result);
8587
+ Py_DECREF_IMMORTAL(result);
8588
8588
  }
8589
8589
  }
8590
8590
 
@@ -8658,7 +8658,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *ope
8658
8658
  }
8659
8659
  }
8660
8660
 
8661
- Py_DECREF(result);
8661
+ Py_DECREF_IMMORTAL(result);
8662
8662
  }
8663
8663
 
8664
8664
  // No rich comparison worked, but maybe compare works.
@@ -8727,7 +8727,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *ope
8727
8727
  }
8728
8728
  }
8729
8729
 
8730
- Py_DECREF(result);
8730
+ Py_DECREF_IMMORTAL(result);
8731
8731
  }
8732
8732
  }
8733
8733
 
@@ -8749,7 +8749,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *ope
8749
8749
  }
8750
8750
  }
8751
8751
 
8752
- Py_DECREF(result);
8752
+ Py_DECREF_IMMORTAL(result);
8753
8753
  }
8754
8754
 
8755
8755
  f = RICHCOMPARE(type2);
@@ -8770,7 +8770,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *ope
8770
8770
  }
8771
8771
  }
8772
8772
 
8773
- Py_DECREF(result);
8773
+ Py_DECREF_IMMORTAL(result);
8774
8774
  }
8775
8775
 
8776
8776
  int c;
@@ -8886,7 +8886,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *ope
8886
8886
  }
8887
8887
  }
8888
8888
 
8889
- Py_DECREF(result);
8889
+ Py_DECREF_IMMORTAL(result);
8890
8890
  }
8891
8891
  }
8892
8892
 
@@ -8909,7 +8909,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *ope
8909
8909
  }
8910
8910
  }
8911
8911
 
8912
- Py_DECREF(result);
8912
+ Py_DECREF_IMMORTAL(result);
8913
8913
  }
8914
8914
 
8915
8915
  if (checked_reverse_op == false) {
@@ -8932,7 +8932,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_FLOAT_OBJECT(PyObject *operand1, PyObject *ope
8932
8932
  }
8933
8933
  }
8934
8934
 
8935
- Py_DECREF(result);
8935
+ Py_DECREF_IMMORTAL(result);
8936
8936
  }
8937
8937
  }
8938
8938
 
@@ -8981,7 +8981,7 @@ static PyObject *COMPARE_EQ_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *ope
8981
8981
 
8982
8982
  // Convert to target type.
8983
8983
  PyObject *result = BOOL_FROM(r);
8984
- Py_INCREF(result);
8984
+ Py_INCREF_IMMORTAL(result);
8985
8985
  return result;
8986
8986
  }
8987
8987
 
@@ -9011,7 +9011,7 @@ static PyObject *COMPARE_EQ_OBJECT_TUPLE_TUPLE(PyObject *operand1, PyObject *ope
9011
9011
 
9012
9012
  // Convert to target type.
9013
9013
  PyObject *result = BOOL_FROM(r);
9014
- Py_INCREF(result);
9014
+ Py_INCREF_IMMORTAL(result);
9015
9015
  return result;
9016
9016
  }
9017
9017
  /* Code referring to "OBJECT" corresponds to any Python object and "TUPLE" to Python 'tuple'. */
@@ -9048,7 +9048,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9048
9048
  return result;
9049
9049
  }
9050
9050
 
9051
- Py_DECREF(result);
9051
+ Py_DECREF_IMMORTAL(result);
9052
9052
  }
9053
9053
 
9054
9054
  // No rich comparison worked, but maybe compare works.
@@ -9089,7 +9089,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9089
9089
 
9090
9090
  bool r = c != 0;
9091
9091
  PyObject *result = BOOL_FROM(r);
9092
- Py_INCREF(result);
9092
+ Py_INCREF_IMMORTAL(result);
9093
9093
  return result;
9094
9094
  }
9095
9095
  }
@@ -9109,7 +9109,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9109
9109
  return result;
9110
9110
  }
9111
9111
 
9112
- Py_DECREF(result);
9112
+ Py_DECREF_IMMORTAL(result);
9113
9113
  }
9114
9114
  }
9115
9115
 
@@ -9123,7 +9123,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9123
9123
  return result;
9124
9124
  }
9125
9125
 
9126
- Py_DECREF(result);
9126
+ Py_DECREF_IMMORTAL(result);
9127
9127
  }
9128
9128
 
9129
9129
  f = PyTuple_Type.tp_richcompare;
@@ -9136,7 +9136,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9136
9136
  return result;
9137
9137
  }
9138
9138
 
9139
- Py_DECREF(result);
9139
+ Py_DECREF_IMMORTAL(result);
9140
9140
  }
9141
9141
 
9142
9142
  int c;
@@ -9224,7 +9224,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9224
9224
 
9225
9225
  bool r = c != 0;
9226
9226
  PyObject *result = BOOL_FROM(r);
9227
- Py_INCREF(result);
9227
+ Py_INCREF_IMMORTAL(result);
9228
9228
  return result;
9229
9229
  #else
9230
9230
  bool checked_reverse_op = false;
@@ -9244,7 +9244,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9244
9244
  return result;
9245
9245
  }
9246
9246
 
9247
- Py_DECREF(result);
9247
+ Py_DECREF_IMMORTAL(result);
9248
9248
  }
9249
9249
  }
9250
9250
 
@@ -9259,7 +9259,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9259
9259
  return result;
9260
9260
  }
9261
9261
 
9262
- Py_DECREF(result);
9262
+ Py_DECREF_IMMORTAL(result);
9263
9263
  }
9264
9264
 
9265
9265
  if (checked_reverse_op == false) {
@@ -9274,7 +9274,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9274
9274
  return result;
9275
9275
  }
9276
9276
 
9277
- Py_DECREF(result);
9277
+ Py_DECREF_IMMORTAL(result);
9278
9278
  }
9279
9279
  }
9280
9280
 
@@ -9286,13 +9286,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_TUPLE(PyObject *operand1, PyObject *oper
9286
9286
  case Py_EQ: {
9287
9287
  bool r = operand1 == operand2;
9288
9288
  PyObject *result = BOOL_FROM(r);
9289
- Py_INCREF(result);
9289
+ Py_INCREF_IMMORTAL(result);
9290
9290
  return result;
9291
9291
  }
9292
9292
  case Py_NE: {
9293
9293
  bool r = operand1 != operand2;
9294
9294
  PyObject *result = BOOL_FROM(r);
9295
- Py_INCREF(result);
9295
+ Py_INCREF_IMMORTAL(result);
9296
9296
  return result;
9297
9297
  }
9298
9298
  default:
@@ -9340,7 +9340,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9340
9340
  return result;
9341
9341
  }
9342
9342
 
9343
- Py_DECREF(result);
9343
+ Py_DECREF_IMMORTAL(result);
9344
9344
  }
9345
9345
 
9346
9346
  // No rich comparison worked, but maybe compare works.
@@ -9381,7 +9381,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9381
9381
 
9382
9382
  bool r = c != 0;
9383
9383
  PyObject *result = BOOL_FROM(r);
9384
- Py_INCREF(result);
9384
+ Py_INCREF_IMMORTAL(result);
9385
9385
  return result;
9386
9386
  }
9387
9387
  }
@@ -9401,7 +9401,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9401
9401
  return result;
9402
9402
  }
9403
9403
 
9404
- Py_DECREF(result);
9404
+ Py_DECREF_IMMORTAL(result);
9405
9405
  }
9406
9406
  }
9407
9407
 
@@ -9415,7 +9415,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9415
9415
  return result;
9416
9416
  }
9417
9417
 
9418
- Py_DECREF(result);
9418
+ Py_DECREF_IMMORTAL(result);
9419
9419
  }
9420
9420
 
9421
9421
  f = RICHCOMPARE(type2);
@@ -9428,7 +9428,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9428
9428
  return result;
9429
9429
  }
9430
9430
 
9431
- Py_DECREF(result);
9431
+ Py_DECREF_IMMORTAL(result);
9432
9432
  }
9433
9433
 
9434
9434
  int c;
@@ -9516,7 +9516,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9516
9516
 
9517
9517
  bool r = c != 0;
9518
9518
  PyObject *result = BOOL_FROM(r);
9519
- Py_INCREF(result);
9519
+ Py_INCREF_IMMORTAL(result);
9520
9520
  return result;
9521
9521
  #else
9522
9522
  bool checked_reverse_op = false;
@@ -9536,7 +9536,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9536
9536
  return result;
9537
9537
  }
9538
9538
 
9539
- Py_DECREF(result);
9539
+ Py_DECREF_IMMORTAL(result);
9540
9540
  }
9541
9541
  }
9542
9542
 
@@ -9551,7 +9551,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9551
9551
  return result;
9552
9552
  }
9553
9553
 
9554
- Py_DECREF(result);
9554
+ Py_DECREF_IMMORTAL(result);
9555
9555
  }
9556
9556
 
9557
9557
  if (checked_reverse_op == false) {
@@ -9566,7 +9566,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9566
9566
  return result;
9567
9567
  }
9568
9568
 
9569
- Py_DECREF(result);
9569
+ Py_DECREF_IMMORTAL(result);
9570
9570
  }
9571
9571
  }
9572
9572
 
@@ -9578,13 +9578,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_TUPLE_OBJECT(PyObject *operand1, PyObject *oper
9578
9578
  case Py_EQ: {
9579
9579
  bool r = operand1 == operand2;
9580
9580
  PyObject *result = BOOL_FROM(r);
9581
- Py_INCREF(result);
9581
+ Py_INCREF_IMMORTAL(result);
9582
9582
  return result;
9583
9583
  }
9584
9584
  case Py_NE: {
9585
9585
  bool r = operand1 != operand2;
9586
9586
  PyObject *result = BOOL_FROM(r);
9587
- Py_INCREF(result);
9587
+ Py_INCREF_IMMORTAL(result);
9588
9588
  return result;
9589
9589
  }
9590
9590
  default:
@@ -9696,7 +9696,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *ope
9696
9696
  }
9697
9697
  }
9698
9698
 
9699
- Py_DECREF(result);
9699
+ Py_DECREF_IMMORTAL(result);
9700
9700
  }
9701
9701
 
9702
9702
  // No rich comparison worked, but maybe compare works.
@@ -9765,7 +9765,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *ope
9765
9765
  }
9766
9766
  }
9767
9767
 
9768
- Py_DECREF(result);
9768
+ Py_DECREF_IMMORTAL(result);
9769
9769
  }
9770
9770
  }
9771
9771
 
@@ -9787,7 +9787,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *ope
9787
9787
  }
9788
9788
  }
9789
9789
 
9790
- Py_DECREF(result);
9790
+ Py_DECREF_IMMORTAL(result);
9791
9791
  }
9792
9792
 
9793
9793
  f = PyTuple_Type.tp_richcompare;
@@ -9808,7 +9808,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *ope
9808
9808
  }
9809
9809
  }
9810
9810
 
9811
- Py_DECREF(result);
9811
+ Py_DECREF_IMMORTAL(result);
9812
9812
  }
9813
9813
 
9814
9814
  int c;
@@ -9924,7 +9924,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *ope
9924
9924
  }
9925
9925
  }
9926
9926
 
9927
- Py_DECREF(result);
9927
+ Py_DECREF_IMMORTAL(result);
9928
9928
  }
9929
9929
  }
9930
9930
 
@@ -9947,7 +9947,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *ope
9947
9947
  }
9948
9948
  }
9949
9949
 
9950
- Py_DECREF(result);
9950
+ Py_DECREF_IMMORTAL(result);
9951
9951
  }
9952
9952
 
9953
9953
  if (checked_reverse_op == false) {
@@ -9970,7 +9970,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_TUPLE(PyObject *operand1, PyObject *ope
9970
9970
  }
9971
9971
  }
9972
9972
 
9973
- Py_DECREF(result);
9973
+ Py_DECREF_IMMORTAL(result);
9974
9974
  }
9975
9975
  }
9976
9976
 
@@ -10044,7 +10044,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *ope
10044
10044
  }
10045
10045
  }
10046
10046
 
10047
- Py_DECREF(result);
10047
+ Py_DECREF_IMMORTAL(result);
10048
10048
  }
10049
10049
 
10050
10050
  // No rich comparison worked, but maybe compare works.
@@ -10113,7 +10113,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *ope
10113
10113
  }
10114
10114
  }
10115
10115
 
10116
- Py_DECREF(result);
10116
+ Py_DECREF_IMMORTAL(result);
10117
10117
  }
10118
10118
  }
10119
10119
 
@@ -10135,7 +10135,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *ope
10135
10135
  }
10136
10136
  }
10137
10137
 
10138
- Py_DECREF(result);
10138
+ Py_DECREF_IMMORTAL(result);
10139
10139
  }
10140
10140
 
10141
10141
  f = RICHCOMPARE(type2);
@@ -10156,7 +10156,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *ope
10156
10156
  }
10157
10157
  }
10158
10158
 
10159
- Py_DECREF(result);
10159
+ Py_DECREF_IMMORTAL(result);
10160
10160
  }
10161
10161
 
10162
10162
  int c;
@@ -10272,7 +10272,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *ope
10272
10272
  }
10273
10273
  }
10274
10274
 
10275
- Py_DECREF(result);
10275
+ Py_DECREF_IMMORTAL(result);
10276
10276
  }
10277
10277
  }
10278
10278
 
@@ -10295,7 +10295,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *ope
10295
10295
  }
10296
10296
  }
10297
10297
 
10298
- Py_DECREF(result);
10298
+ Py_DECREF_IMMORTAL(result);
10299
10299
  }
10300
10300
 
10301
10301
  if (checked_reverse_op == false) {
@@ -10318,7 +10318,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_TUPLE_OBJECT(PyObject *operand1, PyObject *ope
10318
10318
  }
10319
10319
  }
10320
10320
 
10321
- Py_DECREF(result);
10321
+ Py_DECREF_IMMORTAL(result);
10322
10322
  }
10323
10323
  }
10324
10324
 
@@ -10370,7 +10370,7 @@ static PyObject *COMPARE_EQ_OBJECT_LIST_LIST(PyObject *operand1, PyObject *opera
10370
10370
 
10371
10371
  // Convert to target type.
10372
10372
  PyObject *result = BOOL_FROM(r);
10373
- Py_INCREF(result);
10373
+ Py_INCREF_IMMORTAL(result);
10374
10374
  return result;
10375
10375
  }
10376
10376
 
@@ -10409,7 +10409,7 @@ static PyObject *COMPARE_EQ_OBJECT_LIST_LIST(PyObject *operand1, PyObject *opera
10409
10409
 
10410
10410
  // Convert to target type.
10411
10411
  PyObject *result = BOOL_FROM(r);
10412
- Py_INCREF(result);
10412
+ Py_INCREF_IMMORTAL(result);
10413
10413
  return result;
10414
10414
  }
10415
10415
  /* Code referring to "OBJECT" corresponds to any Python object and "LIST" to Python 'list'. */
@@ -10446,7 +10446,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10446
10446
  return result;
10447
10447
  }
10448
10448
 
10449
- Py_DECREF(result);
10449
+ Py_DECREF_IMMORTAL(result);
10450
10450
  }
10451
10451
 
10452
10452
  // No rich comparison worked, but maybe compare works.
@@ -10487,7 +10487,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10487
10487
 
10488
10488
  bool r = c != 0;
10489
10489
  PyObject *result = BOOL_FROM(r);
10490
- Py_INCREF(result);
10490
+ Py_INCREF_IMMORTAL(result);
10491
10491
  return result;
10492
10492
  }
10493
10493
  }
@@ -10507,7 +10507,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10507
10507
  return result;
10508
10508
  }
10509
10509
 
10510
- Py_DECREF(result);
10510
+ Py_DECREF_IMMORTAL(result);
10511
10511
  }
10512
10512
  }
10513
10513
 
@@ -10521,7 +10521,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10521
10521
  return result;
10522
10522
  }
10523
10523
 
10524
- Py_DECREF(result);
10524
+ Py_DECREF_IMMORTAL(result);
10525
10525
  }
10526
10526
 
10527
10527
  f = PyList_Type.tp_richcompare;
@@ -10534,7 +10534,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10534
10534
  return result;
10535
10535
  }
10536
10536
 
10537
- Py_DECREF(result);
10537
+ Py_DECREF_IMMORTAL(result);
10538
10538
  }
10539
10539
 
10540
10540
  int c;
@@ -10622,7 +10622,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10622
10622
 
10623
10623
  bool r = c != 0;
10624
10624
  PyObject *result = BOOL_FROM(r);
10625
- Py_INCREF(result);
10625
+ Py_INCREF_IMMORTAL(result);
10626
10626
  return result;
10627
10627
  #else
10628
10628
  bool checked_reverse_op = false;
@@ -10642,7 +10642,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10642
10642
  return result;
10643
10643
  }
10644
10644
 
10645
- Py_DECREF(result);
10645
+ Py_DECREF_IMMORTAL(result);
10646
10646
  }
10647
10647
  }
10648
10648
 
@@ -10657,7 +10657,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10657
10657
  return result;
10658
10658
  }
10659
10659
 
10660
- Py_DECREF(result);
10660
+ Py_DECREF_IMMORTAL(result);
10661
10661
  }
10662
10662
 
10663
10663
  if (checked_reverse_op == false) {
@@ -10672,7 +10672,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10672
10672
  return result;
10673
10673
  }
10674
10674
 
10675
- Py_DECREF(result);
10675
+ Py_DECREF_IMMORTAL(result);
10676
10676
  }
10677
10677
  }
10678
10678
 
@@ -10684,13 +10684,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_OBJECT_LIST(PyObject *operand1, PyObject *opera
10684
10684
  case Py_EQ: {
10685
10685
  bool r = operand1 == operand2;
10686
10686
  PyObject *result = BOOL_FROM(r);
10687
- Py_INCREF(result);
10687
+ Py_INCREF_IMMORTAL(result);
10688
10688
  return result;
10689
10689
  }
10690
10690
  case Py_NE: {
10691
10691
  bool r = operand1 != operand2;
10692
10692
  PyObject *result = BOOL_FROM(r);
10693
- Py_INCREF(result);
10693
+ Py_INCREF_IMMORTAL(result);
10694
10694
  return result;
10695
10695
  }
10696
10696
  default:
@@ -10738,7 +10738,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10738
10738
  return result;
10739
10739
  }
10740
10740
 
10741
- Py_DECREF(result);
10741
+ Py_DECREF_IMMORTAL(result);
10742
10742
  }
10743
10743
 
10744
10744
  // No rich comparison worked, but maybe compare works.
@@ -10779,7 +10779,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10779
10779
 
10780
10780
  bool r = c != 0;
10781
10781
  PyObject *result = BOOL_FROM(r);
10782
- Py_INCREF(result);
10782
+ Py_INCREF_IMMORTAL(result);
10783
10783
  return result;
10784
10784
  }
10785
10785
  }
@@ -10799,7 +10799,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10799
10799
  return result;
10800
10800
  }
10801
10801
 
10802
- Py_DECREF(result);
10802
+ Py_DECREF_IMMORTAL(result);
10803
10803
  }
10804
10804
  }
10805
10805
 
@@ -10813,7 +10813,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10813
10813
  return result;
10814
10814
  }
10815
10815
 
10816
- Py_DECREF(result);
10816
+ Py_DECREF_IMMORTAL(result);
10817
10817
  }
10818
10818
 
10819
10819
  f = RICHCOMPARE(type2);
@@ -10826,7 +10826,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10826
10826
  return result;
10827
10827
  }
10828
10828
 
10829
- Py_DECREF(result);
10829
+ Py_DECREF_IMMORTAL(result);
10830
10830
  }
10831
10831
 
10832
10832
  int c;
@@ -10914,7 +10914,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10914
10914
 
10915
10915
  bool r = c != 0;
10916
10916
  PyObject *result = BOOL_FROM(r);
10917
- Py_INCREF(result);
10917
+ Py_INCREF_IMMORTAL(result);
10918
10918
  return result;
10919
10919
  #else
10920
10920
  bool checked_reverse_op = false;
@@ -10934,7 +10934,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10934
10934
  return result;
10935
10935
  }
10936
10936
 
10937
- Py_DECREF(result);
10937
+ Py_DECREF_IMMORTAL(result);
10938
10938
  }
10939
10939
  }
10940
10940
 
@@ -10949,7 +10949,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10949
10949
  return result;
10950
10950
  }
10951
10951
 
10952
- Py_DECREF(result);
10952
+ Py_DECREF_IMMORTAL(result);
10953
10953
  }
10954
10954
 
10955
10955
  if (checked_reverse_op == false) {
@@ -10964,7 +10964,7 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10964
10964
  return result;
10965
10965
  }
10966
10966
 
10967
- Py_DECREF(result);
10967
+ Py_DECREF_IMMORTAL(result);
10968
10968
  }
10969
10969
  }
10970
10970
 
@@ -10976,13 +10976,13 @@ PyObject *RICH_COMPARE_EQ_OBJECT_LIST_OBJECT(PyObject *operand1, PyObject *opera
10976
10976
  case Py_EQ: {
10977
10977
  bool r = operand1 == operand2;
10978
10978
  PyObject *result = BOOL_FROM(r);
10979
- Py_INCREF(result);
10979
+ Py_INCREF_IMMORTAL(result);
10980
10980
  return result;
10981
10981
  }
10982
10982
  case Py_NE: {
10983
10983
  bool r = operand1 != operand2;
10984
10984
  PyObject *result = BOOL_FROM(r);
10985
- Py_INCREF(result);
10985
+ Py_INCREF_IMMORTAL(result);
10986
10986
  return result;
10987
10987
  }
10988
10988
  default:
@@ -11100,7 +11100,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *oper
11100
11100
  }
11101
11101
  }
11102
11102
 
11103
- Py_DECREF(result);
11103
+ Py_DECREF_IMMORTAL(result);
11104
11104
  }
11105
11105
 
11106
11106
  // No rich comparison worked, but maybe compare works.
@@ -11169,7 +11169,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *oper
11169
11169
  }
11170
11170
  }
11171
11171
 
11172
- Py_DECREF(result);
11172
+ Py_DECREF_IMMORTAL(result);
11173
11173
  }
11174
11174
  }
11175
11175
 
@@ -11191,7 +11191,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *oper
11191
11191
  }
11192
11192
  }
11193
11193
 
11194
- Py_DECREF(result);
11194
+ Py_DECREF_IMMORTAL(result);
11195
11195
  }
11196
11196
 
11197
11197
  f = PyList_Type.tp_richcompare;
@@ -11212,7 +11212,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *oper
11212
11212
  }
11213
11213
  }
11214
11214
 
11215
- Py_DECREF(result);
11215
+ Py_DECREF_IMMORTAL(result);
11216
11216
  }
11217
11217
 
11218
11218
  int c;
@@ -11328,7 +11328,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *oper
11328
11328
  }
11329
11329
  }
11330
11330
 
11331
- Py_DECREF(result);
11331
+ Py_DECREF_IMMORTAL(result);
11332
11332
  }
11333
11333
  }
11334
11334
 
@@ -11351,7 +11351,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *oper
11351
11351
  }
11352
11352
  }
11353
11353
 
11354
- Py_DECREF(result);
11354
+ Py_DECREF_IMMORTAL(result);
11355
11355
  }
11356
11356
 
11357
11357
  if (checked_reverse_op == false) {
@@ -11374,7 +11374,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_OBJECT_LIST(PyObject *operand1, PyObject *oper
11374
11374
  }
11375
11375
  }
11376
11376
 
11377
- Py_DECREF(result);
11377
+ Py_DECREF_IMMORTAL(result);
11378
11378
  }
11379
11379
  }
11380
11380
 
@@ -11448,7 +11448,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *oper
11448
11448
  }
11449
11449
  }
11450
11450
 
11451
- Py_DECREF(result);
11451
+ Py_DECREF_IMMORTAL(result);
11452
11452
  }
11453
11453
 
11454
11454
  // No rich comparison worked, but maybe compare works.
@@ -11517,7 +11517,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *oper
11517
11517
  }
11518
11518
  }
11519
11519
 
11520
- Py_DECREF(result);
11520
+ Py_DECREF_IMMORTAL(result);
11521
11521
  }
11522
11522
  }
11523
11523
 
@@ -11539,7 +11539,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *oper
11539
11539
  }
11540
11540
  }
11541
11541
 
11542
- Py_DECREF(result);
11542
+ Py_DECREF_IMMORTAL(result);
11543
11543
  }
11544
11544
 
11545
11545
  f = RICHCOMPARE(type2);
@@ -11560,7 +11560,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *oper
11560
11560
  }
11561
11561
  }
11562
11562
 
11563
- Py_DECREF(result);
11563
+ Py_DECREF_IMMORTAL(result);
11564
11564
  }
11565
11565
 
11566
11566
  int c;
@@ -11676,7 +11676,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *oper
11676
11676
  }
11677
11677
  }
11678
11678
 
11679
- Py_DECREF(result);
11679
+ Py_DECREF_IMMORTAL(result);
11680
11680
  }
11681
11681
  }
11682
11682
 
@@ -11699,7 +11699,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *oper
11699
11699
  }
11700
11700
  }
11701
11701
 
11702
- Py_DECREF(result);
11702
+ Py_DECREF_IMMORTAL(result);
11703
11703
  }
11704
11704
 
11705
11705
  if (checked_reverse_op == false) {
@@ -11722,7 +11722,7 @@ nuitka_bool RICH_COMPARE_EQ_NBOOL_LIST_OBJECT(PyObject *operand1, PyObject *oper
11722
11722
  }
11723
11723
  }
11724
11724
 
11725
- Py_DECREF(result);
11725
+ Py_DECREF_IMMORTAL(result);
11726
11726
  }
11727
11727
  }
11728
11728
 
@@ -11812,7 +11812,7 @@ static PyObject *COMPARE_EQ_OBJECT_LONG_CLONG(PyObject *operand1, long operand2)
11812
11812
 
11813
11813
  // Convert to target type.
11814
11814
  PyObject *result = BOOL_FROM(r);
11815
- Py_INCREF(result);
11815
+ Py_INCREF_IMMORTAL(result);
11816
11816
  return result;
11817
11817
  }
11818
11818
  /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "INT" to Python2 'int'. */
@@ -11896,7 +11896,7 @@ static PyObject *COMPARE_EQ_OBJECT_INT_CLONG(PyObject *operand1, long operand2)
11896
11896
 
11897
11897
  // Convert to target type.
11898
11898
  PyObject *result = BOOL_FROM(r);
11899
- Py_INCREF(result);
11899
+ Py_INCREF_IMMORTAL(result);
11900
11900
  return result;
11901
11901
  }
11902
11902
  /* Code referring to "INT" corresponds to Python2 'int' and "CLONG" to C platform long value. */
@@ -11954,7 +11954,7 @@ static PyObject *COMPARE_EQ_OBJECT_LONG_DIGIT(PyObject *operand1, long operand2)
11954
11954
 
11955
11955
  // Convert to target type.
11956
11956
  PyObject *result = BOOL_FROM(r);
11957
- Py_INCREF(result);
11957
+ Py_INCREF_IMMORTAL(result);
11958
11958
  return result;
11959
11959
  }
11960
11960
  /* Code referring to "LONG" corresponds to Python2 'long', Python3 'int' and "DIGIT" to C platform digit value for long
@@ -12011,7 +12011,7 @@ static PyObject *COMPARE_EQ_OBJECT_FLOAT_CFLOAT(PyObject *operand1, double opera
12011
12011
 
12012
12012
  // Convert to target type.
12013
12013
  PyObject *result = BOOL_FROM(r);
12014
- Py_INCREF(result);
12014
+ Py_INCREF_IMMORTAL(result);
12015
12015
  return result;
12016
12016
  }
12017
12017
  /* Code referring to "FLOAT" corresponds to Python 'float' and "CFLOAT" to C platform float value. */