gh-126612: Include stack effects of uops when computing maximum stack depth (#126894)

1 files changed, 925 insertions, 0 deletions

diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h
index 5328087..5ce1728 100644
--- a/Include/internal/pycore_opcode_metadata.h
+++ b/Include/internal/pycore_opcode_metadata.h
@@ -949,6 +949,931 @@ int _PyOpcode_num_pushed(int opcode, int oparg)  {
 
 #endif
 
+extern int _PyOpcode_max_stack_effect(int opcode, int oparg, int *effect);
+#ifdef NEED_OPCODE_METADATA
+int _PyOpcode_max_stack_effect(int opcode, int oparg, int *effect)  {
+    switch(opcode) {
+        case BINARY_OP: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_OP_ADD_FLOAT: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_OP_ADD_INT: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_OP_ADD_UNICODE: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_OP_INPLACE_ADD_UNICODE: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_OP_MULTIPLY_FLOAT: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_OP_MULTIPLY_INT: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_OP_SUBTRACT_FLOAT: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_OP_SUBTRACT_INT: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_SLICE: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_SUBSCR: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_SUBSCR_DICT: {
+            *effect = -1;
+            return 0;
+        }
+        case BINARY_SUBSCR_GETITEM: {
+            *effect = 0;
+            return 0;
+        }
+        case BINARY_SUBSCR_LIST_INT: {
+            *effect = -1;
+            return 0;
+        }
+        case BINARY_SUBSCR_STR_INT: {
+            *effect = -1;
+            return 0;
+        }
+        case BINARY_SUBSCR_TUPLE_INT: {
+            *effect = -1;
+            return 0;
+        }
+        case BUILD_LIST: {
+            *effect = 1 - oparg;
+            return 0;
+        }
+        case BUILD_MAP: {
+            *effect = 1 - oparg*2;
+            return 0;
+        }
+        case BUILD_SET: {
+            *effect = 1 - oparg;
+            return 0;
+        }
+        case BUILD_SLICE: {
+            *effect = -1 - ((oparg == 3) ? 1 : 0);
+            return 0;
+        }
+        case BUILD_STRING: {
+            *effect = 1 - oparg;
+            return 0;
+        }
+        case BUILD_TUPLE: {
+            *effect = 1 - oparg;
+            return 0;
+        }
+        case CACHE: {
+            *effect = 0;
+            return 0;
+        }
+        case CALL: {
+            int max_eff = Py_MAX(0, -1 - oparg);
+            max_eff = Py_MAX(max_eff, -2 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_ALLOC_AND_ENTER_INIT: {
+            int max_eff = Py_MAX(0, -1 - oparg);
+            max_eff = Py_MAX(max_eff, -2 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_BOUND_METHOD_EXACT_ARGS: {
+            int max_eff = Py_MAX(0, -1 - oparg);
+            max_eff = Py_MAX(max_eff, -2 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_BOUND_METHOD_GENERAL: {
+            int max_eff = Py_MAX(0, -1 - oparg);
+            max_eff = Py_MAX(max_eff, -2 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_BUILTIN_CLASS: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_BUILTIN_FAST: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_BUILTIN_FAST_WITH_KEYWORDS: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_BUILTIN_O: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_FUNCTION_EX: {
+            *effect = Py_MAX(0, -2 - (oparg & 1));
+            return 0;
+        }
+        case CALL_INTRINSIC_1: {
+            *effect = 0;
+            return 0;
+        }
+        case CALL_INTRINSIC_2: {
+            *effect = -1;
+            return 0;
+        }
+        case CALL_ISINSTANCE: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_KW: {
+            int max_eff = Py_MAX(0, -2 - oparg);
+            max_eff = Py_MAX(max_eff, -3 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_KW_BOUND_METHOD: {
+            int max_eff = Py_MAX(0, -2 - oparg);
+            max_eff = Py_MAX(max_eff, -3 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_KW_NON_PY: {
+            *effect = Py_MAX(0, -2 - oparg);
+            return 0;
+        }
+        case CALL_KW_PY: {
+            int max_eff = Py_MAX(0, -2 - oparg);
+            max_eff = Py_MAX(max_eff, -3 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_LEN: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_LIST_APPEND: {
+            *effect = -3;
+            return 0;
+        }
+        case CALL_METHOD_DESCRIPTOR_FAST: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_METHOD_DESCRIPTOR_NOARGS: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_METHOD_DESCRIPTOR_O: {
+            *effect = -1 - oparg;
+            return 0;
+        }
+        case CALL_NON_PY_GENERAL: {
+            *effect = Py_MAX(0, -1 - oparg);
+            return 0;
+        }
+        case CALL_PY_EXACT_ARGS: {
+            int max_eff = Py_MAX(0, -1 - oparg);
+            max_eff = Py_MAX(max_eff, -2 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_PY_GENERAL: {
+            int max_eff = Py_MAX(0, -1 - oparg);
+            max_eff = Py_MAX(max_eff, -2 - oparg);
+            *effect = max_eff;
+            return 0;
+        }
+        case CALL_STR_1: {
+            *effect = -2;
+            return 0;
+        }
+        case CALL_TUPLE_1: {
+            *effect = -2;
+            return 0;
+        }
+        case CALL_TYPE_1: {
+            *effect = -2;
+            return 0;
+        }
+        case CHECK_EG_MATCH: {
+            *effect = 0;
+            return 0;
+        }
+        case CHECK_EXC_MATCH: {
+            *effect = 0;
+            return 0;
+        }
+        case CLEANUP_THROW: {
+            *effect = -1;
+            return 0;
+        }
+        case COMPARE_OP: {
+            *effect = 0;
+            return 0;
+        }
+        case COMPARE_OP_FLOAT: {
+            *effect = 0;
+            return 0;
+        }
+        case COMPARE_OP_INT: {
+            *effect = 0;
+            return 0;
+        }
+        case COMPARE_OP_STR: {
+            *effect = 0;
+            return 0;
+        }
+        case CONTAINS_OP: {
+            *effect = 0;
+            return 0;
+        }
+        case CONTAINS_OP_DICT: {
+            *effect = -1;
+            return 0;
+        }
+        case CONTAINS_OP_SET: {
+            *effect = -1;
+            return 0;
+        }
+        case CONVERT_VALUE: {
+            *effect = 0;
+            return 0;
+        }
+        case COPY: {
+            *effect = 1;
+            return 0;
+        }
+        case COPY_FREE_VARS: {
+            *effect = 0;
+            return 0;
+        }
+        case DELETE_ATTR: {
+            *effect = -1;
+            return 0;
+        }
+        case DELETE_DEREF: {
+            *effect = 0;
+            return 0;
+        }
+        case DELETE_FAST: {
+            *effect = 0;
+            return 0;
+        }
+        case DELETE_GLOBAL: {
+            *effect = 0;
+            return 0;
+        }
+        case DELETE_NAME: {
+            *effect = 0;
+            return 0;
+        }
+        case DELETE_SUBSCR: {
+            *effect = -2;
+            return 0;
+        }
+        case DICT_MERGE: {
+            *effect = -1;
+            return 0;
+        }
+        case DICT_UPDATE: {
+            *effect = -1;
+            return 0;
+        }
+        case END_ASYNC_FOR: {
+            *effect = -2;
+            return 0;
+        }
+        case END_FOR: {
+            *effect = -1;
+            return 0;
+        }
+        case END_SEND: {
+            *effect = -1;
+            return 0;
+        }
+        case ENTER_EXECUTOR: {
+            *effect = 0;
+            return 0;
+        }
+        case EXIT_INIT_CHECK: {
+            *effect = -1;
+            return 0;
+        }
+        case EXTENDED_ARG: {
+            *effect = 0;
+            return 0;
+        }
+        case FORMAT_SIMPLE: {
+            *effect = 0;
+            return 0;
+        }
+        case FORMAT_WITH_SPEC: {
+            *effect = -1;
+            return 0;
+        }
+        case FOR_ITER: {
+            *effect = 1;
+            return 0;
+        }
+        case FOR_ITER_GEN: {
+            *effect = 1;
+            return 0;
+        }
+        case FOR_ITER_LIST: {
+            *effect = 1;
+            return 0;
+        }
+        case FOR_ITER_RANGE: {
+            *effect = 1;
+            return 0;
+        }
+        case FOR_ITER_TUPLE: {
+            *effect = 1;
+            return 0;
+        }
+        case GET_AITER: {
+            *effect = 0;
+            return 0;
+        }
+        case GET_ANEXT: {
+            *effect = 1;
+            return 0;
+        }
+        case GET_AWAITABLE: {
+            *effect = 0;
+            return 0;
+        }
+        case GET_ITER: {
+            *effect = 0;
+            return 0;
+        }
+        case GET_LEN: {
+            *effect = 1;
+            return 0;
+        }
+        case GET_YIELD_FROM_ITER: {
+            *effect = 0;
+            return 0;
+        }
+        case IMPORT_FROM: {
+            *effect = 1;
+            return 0;
+        }
+        case IMPORT_NAME: {
+            *effect = -1;
+            return 0;
+        }
+        case INSTRUMENTED_CALL: {
+            *effect = Py_MAX(0, -1 - oparg);
+            return 0;
+        }
+        case INSTRUMENTED_CALL_FUNCTION_EX: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_CALL_KW: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_END_FOR: {
+            *effect = -1;
+            return 0;
+        }
+        case INSTRUMENTED_END_SEND: {
+            *effect = -1;
+            return 0;
+        }
+        case INSTRUMENTED_FOR_ITER: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_INSTRUCTION: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_JUMP_BACKWARD: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_JUMP_FORWARD: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_LINE: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_LOAD_SUPER_ATTR: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_POP_JUMP_IF_FALSE: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_POP_JUMP_IF_NONE: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_POP_JUMP_IF_NOT_NONE: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_POP_JUMP_IF_TRUE: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_RESUME: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_RETURN_VALUE: {
+            *effect = 0;
+            return 0;
+        }
+        case INSTRUMENTED_YIELD_VALUE: {
+            *effect = 0;
+            return 0;
+        }
+        case INTERPRETER_EXIT: {
+            *effect = -1;
+            return 0;
+        }
+        case IS_OP: {
+            *effect = -1;
+            return 0;
+        }
+        case JUMP: {
+            *effect = 0;
+            return 0;
+        }
+        case JUMP_BACKWARD: {
+            *effect = 0;
+            return 0;
+        }
+        case JUMP_BACKWARD_NO_INTERRUPT: {
+            *effect = 0;
+            return 0;
+        }
+        case JUMP_FORWARD: {
+            *effect = 0;
+            return 0;
+        }
+        case JUMP_IF_FALSE: {
+            *effect = 0;
+            return 0;
+        }
+        case JUMP_IF_TRUE: {
+            *effect = 0;
+            return 0;
+        }
+        case JUMP_NO_INTERRUPT: {
+            *effect = 0;
+            return 0;
+        }
+        case LIST_APPEND: {
+            *effect = -1;
+            return 0;
+        }
+        case LIST_EXTEND: {
+            *effect = -1;
+            return 0;
+        }
+        case LOAD_ATTR: {
+            *effect = Py_MAX(1, (oparg & 1));
+            return 0;
+        }
+        case LOAD_ATTR_CLASS: {
+            *effect = Py_MAX(0, (oparg & 1));
+            return 0;
+        }
+        case LOAD_ATTR_CLASS_WITH_METACLASS_CHECK: {
+            *effect = Py_MAX(0, (oparg & 1));
+            return 0;
+        }
+        case LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN: {
+            *effect = 0;
+            return 0;
+        }
+        case LOAD_ATTR_INSTANCE_VALUE: {
+            *effect = Py_MAX(0, (oparg & 1));
+            return 0;
+        }
+        case LOAD_ATTR_METHOD_LAZY_DICT: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_ATTR_METHOD_NO_DICT: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_ATTR_METHOD_WITH_VALUES: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_ATTR_MODULE: {
+            *effect = Py_MAX(0, (oparg & 1));
+            return 0;
+        }
+        case LOAD_ATTR_NONDESCRIPTOR_NO_DICT: {
+            *effect = 0;
+            return 0;
+        }
+        case LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: {
+            *effect = 0;
+            return 0;
+        }
+        case LOAD_ATTR_PROPERTY: {
+            *effect = 0;
+            return 0;
+        }
+        case LOAD_ATTR_SLOT: {
+            *effect = Py_MAX(0, (oparg & 1));
+            return 0;
+        }
+        case LOAD_ATTR_WITH_HINT: {
+            *effect = Py_MAX(0, (oparg & 1));
+            return 0;
+        }
+        case LOAD_BUILD_CLASS: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_CLOSURE: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_COMMON_CONSTANT: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_CONST: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_CONST_IMMORTAL: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_DEREF: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_FAST: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_FAST_AND_CLEAR: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_FAST_CHECK: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_FAST_LOAD_FAST: {
+            *effect = 2;
+            return 0;
+        }
+        case LOAD_FROM_DICT_OR_DEREF: {
+            *effect = 0;
+            return 0;
+        }
+        case LOAD_FROM_DICT_OR_GLOBALS: {
+            *effect = 0;
+            return 0;
+        }
+        case LOAD_GLOBAL: {
+            *effect = Py_MAX(1, 1 + (oparg & 1));
+            return 0;
+        }
+        case LOAD_GLOBAL_BUILTIN: {
+            *effect = Py_MAX(1, 1 + (oparg & 1));
+            return 0;
+        }
+        case LOAD_GLOBAL_MODULE: {
+            *effect = Py_MAX(1, 1 + (oparg & 1));
+            return 0;
+        }
+        case LOAD_LOCALS: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_NAME: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_SMALL_INT: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_SPECIAL: {
+            *effect = 1;
+            return 0;
+        }
+        case LOAD_SUPER_ATTR: {
+            *effect = Py_MAX(0, -2 + (oparg & 1));
+            return 0;
+        }
+        case LOAD_SUPER_ATTR_ATTR: {
+            *effect = -2;
+            return 0;
+        }
+        case LOAD_SUPER_ATTR_METHOD: {
+            *effect = -1;
+            return 0;
+        }
+        case MAKE_CELL: {
+            *effect = 0;
+            return 0;
+        }
+        case MAKE_FUNCTION: {
+            *effect = 0;
+            return 0;
+        }
+        case MAP_ADD: {
+            *effect = -2;
+            return 0;
+        }
+        case MATCH_CLASS: {
+            *effect = -2;
+            return 0;
+        }
+        case MATCH_KEYS: {
+            *effect = 1;
+            return 0;
+        }
+        case MATCH_MAPPING: {
+            *effect = 1;
+            return 0;
+        }
+        case MATCH_SEQUENCE: {
+            *effect = 1;
+            return 0;
+        }
+        case NOP: {
+            *effect = 0;
+            return 0;
+        }
+        case POP_BLOCK: {
+            *effect = 0;
+            return 0;
+        }
+        case POP_EXCEPT: {
+            *effect = -1;
+            return 0;
+        }
+        case POP_JUMP_IF_FALSE: {
+            *effect = -1;
+            return 0;
+        }
+        case POP_JUMP_IF_NONE: {
+            *effect = 0;
+            return 0;
+        }
+        case POP_JUMP_IF_NOT_NONE: {
+            *effect = 0;
+            return 0;
+        }
+        case POP_JUMP_IF_TRUE: {
+            *effect = -1;
+            return 0;
+        }
+        case POP_TOP: {
+            *effect = -1;
+            return 0;
+        }
+        case PUSH_EXC_INFO: {
+            *effect = 1;
+            return 0;
+        }
+        case PUSH_NULL: {
+            *effect = 1;
+            return 0;
+        }
+        case RAISE_VARARGS: {
+            *effect = -oparg;
+            return 0;
+        }
+        case RERAISE: {
+            *effect = -1;
+            return 0;
+        }
+        case RESERVED: {
+            *effect = 0;
+            return 0;
+        }
+        case RESUME: {
+            *effect = 0;
+            return 0;
+        }
+        case RESUME_CHECK: {
+            *effect = 0;
+            return 0;
+        }
+        case RETURN_GENERATOR: {
+            *effect = 1;
+            return 0;
+        }
+        case RETURN_VALUE: {
+            *effect = 0;
+            return 0;
+        }
+        case SEND: {
+            *effect = 0;
+            return 0;
+        }
+        case SEND_GEN: {
+            *effect = 0;
+            return 0;
+        }
+        case SETUP_ANNOTATIONS: {
+            *effect = 0;
+            return 0;
+        }
+        case SETUP_CLEANUP: {
+            *effect = 2;
+            return 0;
+        }
+        case SETUP_FINALLY: {
+            *effect = 1;
+            return 0;
+        }
+        case SETUP_WITH: {
+            *effect = 1;
+            return 0;
+        }
+        case SET_ADD: {
+            *effect = -1;
+            return 0;
+        }
+        case SET_FUNCTION_ATTRIBUTE: {
+            *effect = -1;
+            return 0;
+        }
+        case SET_UPDATE: {
+            *effect = -1;
+            return 0;
+        }
+        case STORE_ATTR: {
+            *effect = 0;
+            return 0;
+        }
+        case STORE_ATTR_INSTANCE_VALUE: {
+            *effect = 0;
+            return 0;
+        }
+        case STORE_ATTR_SLOT: {
+            *effect = 0;
+            return 0;
+        }
+        case STORE_ATTR_WITH_HINT: {
+            *effect = 0;
+            return 0;
+        }
+        case STORE_DEREF: {
+            *effect = -1;
+            return 0;
+        }
+        case STORE_FAST: {
+            *effect = -1;
+            return 0;
+        }
+        case STORE_FAST_LOAD_FAST: {
+            *effect = 0;
+            return 0;
+        }
+        case STORE_FAST_MAYBE_NULL: {
+            *effect = -1;
+            return 0;
+        }
+        case STORE_FAST_STORE_FAST: {
+            *effect = -2;
+            return 0;
+        }
+        case STORE_GLOBAL: {
+            *effect = -1;
+            return 0;
+        }
+        case STORE_NAME: {
+            *effect = -1;
+            return 0;
+        }
+        case STORE_SLICE: {
+            *effect = 0;
+            return 0;
+        }
+        case STORE_SUBSCR: {
+            *effect = 0;
+            return 0;
+        }
+        case STORE_SUBSCR_DICT: {
+            *effect = -3;
+            return 0;
+        }
+        case STORE_SUBSCR_LIST_INT: {
+            *effect = -3;
+            return 0;
+        }
+        case SWAP: {
+            *effect = 0;
+            return 0;
+        }
+        case TO_BOOL: {
+            *effect = 0;
+            return 0;
+        }
+        case TO_BOOL_ALWAYS_TRUE: {
+            *effect = 0;
+            return 0;
+        }
+        case TO_BOOL_BOOL: {
+            *effect = 0;
+            return 0;
+        }
+        case TO_BOOL_INT: {
+            *effect = 0;
+            return 0;
+        }
+        case TO_BOOL_LIST: {
+            *effect = 0;
+            return 0;
+        }
+        case TO_BOOL_NONE: {
+            *effect = 0;
+            return 0;
+        }
+        case TO_BOOL_STR: {
+            *effect = 0;
+            return 0;
+        }
+        case UNARY_INVERT: {
+            *effect = 0;
+            return 0;
+        }
+        case UNARY_NEGATIVE: {
+            *effect = 0;
+            return 0;
+        }
+        case UNARY_NOT: {
+            *effect = 0;
+            return 0;
+        }
+        case UNPACK_EX: {
+            *effect = (oparg & 0xFF) + (oparg >> 8);
+            return 0;
+        }
+        case UNPACK_SEQUENCE: {
+            *effect = Py_MAX(1, -1 + oparg);
+            return 0;
+        }
+        case UNPACK_SEQUENCE_LIST: {
+            *effect = -1 + oparg;
+            return 0;
+        }
+        case UNPACK_SEQUENCE_TUPLE: {
+            *effect = -1 + oparg;
+            return 0;
+        }
+        case UNPACK_SEQUENCE_TWO_TUPLE: {
+            *effect = 1;
+            return 0;
+        }
+        case WITH_EXCEPT_START: {
+            *effect = 1;
+            return 0;
+        }
+        case YIELD_VALUE: {
+            *effect = 0;
+            return 0;
+        }
+        default:
+            return -1;
+    }
+}
+
+#endif
+
 enum InstructionFormat {
     INSTR_FMT_IB = 1,
     INSTR_FMT_IBC = 2,