Function A Key-Value Pair

a key,value entry

Format:

pair (key, value)

Input:

Output:

Properties that reference this function:

Conditional properties that reference this function:

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Control Map at time (t + 1) = result of storing (pair ("class", name)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then the line at time (t + 1) = the line at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Expression Stack at time t = [ ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then "if" map at time (t + 1) = "if" map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Expression Stack at time (t + 1) = Expression Stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • Parameters List at time t = [ ]
  • Expression Stack at time t = [ [ ], [ [ obj_name.method_name(args), ys ], rest ] ]
  • value at obj_name in map (Variables Map at time t) = Python reference index
  • the element at index index of stack (Python Object Store at time t) = Python object: [ entry "__class_name__": class_name, e_rest ]
  • line number of method method_name of class class_name in (Class Map at time t) = line

  then Control Map at time (t + 1) = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", method_name)), [ ] ] ]

  (link)

• if the following are true:

  • Parameters List at time t = [ ]
  • Expression Stack at time t = [ [ ], [ [ Python constructor with name: class_name and arguments: args, ys ], rest ] ]
  • line number of method "__init__" of class class_name in (Class Map at time t) = line

  then Control Map at time (t + 1) = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", "__init__")), [ ] ] ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Variables Map at time (t + 1) = varis

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then the line at time (t + 1) = line

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then the tab at time (t + 1) = tab

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Expression Stack at time (t + 1) = expr_stack

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Context Stack at time (t + 1) = rest

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Value Stack at time (t + 1) = value_stack

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • Context Stack at time t = [ program context with variables: varis and expression state: (expression state with expression stack: expr_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Control Map at time (t + 1) = control_map

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", "__init__")

  then Return Value at time (t + 1) = [ value at self in map (Variables Map at time t), [ ] ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)
  • not (method_name = "__init__")

  then Return Value at time (t + 1) = [ None, [ ] ]

  (link)

• if the following are true:

  • Expression Stack at time t = [ [ ], [ [ super(), ys ], rest ] ]
  • Value Stack at time t = [ [ ], [ next_level, other_levels ] ]
  • Control Map at time t = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", method_name)), [ ] ] ]
  • definition of method method_name of class class_name in (Class Map at time t) = method_map
  • value at "params" in map method_map = [ param_name, other_params ]
  • value at param_name in map (Variables Map at time t) = Python reference pi

  then Expression Stack at time (t + 1) = [ ys, rest ]

  (link)

• if the following are true:

  • Expression Stack at time t = [ [ ], [ [ super(), ys ], rest ] ]
  • Value Stack at time t = [ [ ], [ next_level, other_levels ] ]
  • Control Map at time t = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", method_name)), [ ] ] ]
  • definition of method method_name of class class_name in (Class Map at time t) = method_map
  • value at "params" in map method_map = [ param_name, other_params ]
  • value at param_name in map (Variables Map at time t) = Python reference pi

  then Value Stack at time (t + 1) = [ [ Python super reference pi class_name, next_level ], other_levels ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the line at time (t + 1) = while_line

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then stack at time (t + 1) = stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then "if" map at time (t + 1) = "if" map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then expression state at time (t + 1) = expression state at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the line at time (t + 1) = while_line

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then stack at time (t + 1) = stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then expression state at time (t + 1) = expression state at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the line at time (t + 1) = i

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then expression state at time (t + 1) = "not_expr"

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then stack at time (t + 1) = stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • expression state at time t = "call_build_args"
  • Parameters List at time t = [ ]
  • the expression at time t = function call with name: name and arguments: args
  • there is a function named name with parameters params at line line

  then Control Map at time (t + 1) = [ entry 0: (pair ("function", name)), [ ] ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then Control Map at time (t + 1) = result of storing (pair ("if", True)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if test:
  • expression state at time t = "end_expr"
  • Return Value at time t = False

  then Control Map at time (t + 1) = result of storing (pair ("if", False)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then the expression at time (t + 1) = test

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then expression state at time (t + 1) = "begin_expr"

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then Value Stack at time (t + 1) = [ ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then parent stack at time (t + 1) = [ ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • expression state at time t = "not_expr"

  then arguments stack at time (t + 1) = [ ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • expression state at time t = "not_expr"

  then the line at time (t + 1) = i + 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • expression state at time t = "not_expr"

  then the tab at time (t + 1) = j

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then Control Map at time (t + 1) = result of storing (pair ("if", True)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", False)

  then the line at time (t + 1) = i + 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", False)

  then the tab at time (t + 1) = j + 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", True)

  then the line at time (t + 1) = i + 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", True)

  then the tab at time (t + 1) = j

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the line at time (t + 1) = i

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then stack at time (t + 1) = stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • expression state at time t = "end_expr"
  • Return Value at time t = True

  then Control Map at time (t + 1) = result of storing (pair ("while", i)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = a class named name with bases: bases

  then Control Map at time (t + 1) = result of storing (pair ("class", name)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then the line at time (t + 1) = the line at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then expression state at time t = "not_expr"

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then stack at time (t + 1) = stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then "if" map at time (t + 1) = "if" map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then expression state at time (t + 1) = expression state at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("class", class_name)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • expression state at time t = "call_build_args"
  • Parameters List at time t = [ ]
  • the expression at time t = obj_name.method_name(args)
  • value at obj_name in map (Variables Map at time t) = Python reference index
  • the element at index index of stack (Python Object Store at time t) = Python object: [ entry "__class_name__": class_name, e_rest ]
  • line number of method method_name of class class_name in (Class Map at time t) = line

  then Control Map at time (t + 1) = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", method_name)), [ ] ] ]

  (link)

• if the following are true:

  • expression state at time t = "call_build_args"
  • Parameters List at time t = [ ]
  • the expression at time t = Python constructor with name: class_name and arguments: args
  • line number of method "__init__" of class class_name in (Class Map at time t) = line

  then Control Map at time (t + 1) = [ entry 0: (pair ("class", class_name)), [ entry 1: (pair ("method", "__init__")), [ ] ] ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then "if" map at time (t + 1) = "if" map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then 'while stack' at time (t + 1) = 'while stack' at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Variables Map at time (t + 1) = varis

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then the line at time (t + 1) = line

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then the tab at time (t + 1) = tab

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then expression state at time (t + 1) = "call_returned"

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then parent stack at time (t + 1) = parent_stack

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then stack at time (t + 1) = rest

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Value Stack at time (t + 1) = value_stack

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then arguments stack at time (t + 1) = arg_stack

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", mname)
  • stack at time t = [ program context with variables: varis and expression state: (expression state with parent stack: parent_stack arguments: arg_stack values: value_stack line: line tab: tab) and control map: control_map, rest ]

  then Control Map at time (t + 1) = control_map

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", "__init__")

  then Return Value at time (t + 1) = value at self in map (Variables Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("method", method_name)
  • not (method_name = "__init__")

  then Return Value at time (t + 1) = None

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the line at time (t + 1) = while_line

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Expression Stack at time (t + 1) = [ ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the line at time (t + 1) = while_line

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Expression Stack at time (t + 1) = [ ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("while", while_line)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the line at time (t + 1) = i

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Expression Stack at time (t + 1) = [ ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • number of lines = i - 1
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • Parameters List at time t = [ ]
  • Expression Stack at time t = [ [ ], [ [ function call with name: name and arguments: args, ys ], rest ] ]
  • there is a function named name with parameters params at line line

  then Control Map at time (t + 1) = [ entry 0: (pair ("function", name)), [ ] ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then Control Map at time (t + 1) = result of storing (pair ("if", True)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = if expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ False, [ ] ], [ ] ]

  then Control Map at time (t + 1) = result of storing (pair ("if", False)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Expression Stack at time (t + 1) = [ [ expr, [ ] ], [ ] ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Value Stack at time (t + 1) = [ [ ], [ ] ]

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", False)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then the line at time (t + 1) = i + 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then the tab at time (t + 1) = j

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif test:
  • value at j in map (Control Map at time t) = pair ("if", True)
  • Expression Stack at time t = [ ]

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = elif expr:
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then Control Map at time (t + 1) = result of storing (pair ("if", True)) at key: j in map: (Control Map at time t)

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", False)

  then the line at time (t + 1) = i + 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", False)

  then the tab at time (t + 1) = j + 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", True)

  then the line at time (t + 1) = i + 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = else:
  • value at j in map (Control Map at time t) = pair ("if", True)

  then the tab at time (t + 1) = j

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the line at time (t + 1) = i

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then the tab at time (t + 1) = j - 1

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Variables Map at time (t + 1) = Variables Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Context Stack at time (t + 1) = Context Stack at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Python Object Store at time (t + 1) = Python Object Store at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Class Map at time (t + 1) = Class Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab k = s
  • k < j
  • value at (j - 1) in map (Control Map at time t) = pair ("if", if_value)

  then Control Map at time (t + 1) = Control Map at time t

  (link)

• if the following are true:

  • the line at time t = i
  • the tab at time t = j
  • statement at line i, tab j = "while" statement with condition (function call with name: name and arguments: args)
  • Expression Stack at time t = [ [ ], [ ] ]
  • Value Stack at time t = [ [ True, [ ] ], [ ] ]

  then Control Map at time (t + 1) = result of storing (pair ("while", i)) at key: j in map: (Control Map at time t)

  (link)

• if entry_key = key, then output of function delete_entry where input key is key, map is [ pair (entry_key, value), remaining ], and processed is kvs = result of dumping kvs to remaining

  (link)

• if not (entry_key = key), then output of function delete_entry where input key is key, map is [ pair (entry_key, value), remaining ], and processed is kvs = output of function delete_entry where input key is key, map is remaining, and processed is [ pair (entry_key, value), kvs ]

  (link)

• if the following are true:

  • not (left = value)
  • not (right = value)

  then output of the find_neighbors function where the input graph is [ pair (left, right), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are result

  (link)

• if left = value, then output of the find_neighbors function where the input graph is [ pair (left, right), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are [ right, result ]

  (link)

• if right = value, then output of the find_neighbors function where the input graph is [ pair (left, right), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are [ left, result ]

  (link)

• if left = value, then output of the find_neighbors function where the input graph is [ edge (left, right, weight), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are [ pair (right, weight), result ]

  (link)

• if right = value, then output of the find_neighbors function where the input graph is [ edge (left, right, weight), rest ], node is value, and children are result = output of the find_neighbors function where the input graph is rest, node is value, and children are [ pair (left, weight), result ]

  (link)

• if tree tree contains value = False, then output of the separate_nodes function where the input tree is tree, the nodes are [ pair (value, weight), rest ], the existing group is exist, and the new group is new = output of the separate_nodes function where the input tree is tree, the nodes are rest, the existing group is exist, and the new group is [ pair (value, weight), new ]

  (link)

• if index of value value in tree = index, then output of the separate_nodes function where the input tree is tree, the nodes are [ pair (value, weight), rest ], the existing group is exist, and the new group is new = output of the separate_nodes function where the input tree is tree, the nodes are rest, the existing group is [ pair (index, weight), exist ], and the new group is new

  (link)

• if the following are true:

  • the element at index child_i of stack tree = node (child_value, child_d, child_prev)
  • distance + weight < child_d
  • result of storing (node (child_value, (distance + weight), index)) at index child_i of stack tree = updated

  then result of updating nodes [ pair (child_i, weight), rest ] in tree tree with parent index index and parent distance distance = result of updating nodes rest in tree updated with parent index index and parent distance distance

  (link)

• if the following are true:

  • the element at index child_i of stack tree = node (child_value, child_d, child_prev)
  • distance + weight > child_d

  then result of updating nodes [ pair (child_i, weight), rest ] in tree tree with parent index index and parent distance distance = result of updating nodes rest in tree tree with parent index index and parent distance distance

  (link)

• if the following are true:

  • ((length of stack tree) - 1) - index = back_i
  • the element at index back_i of stack tree = node (value, distance, previous)
  • result of splitting pairs into nodes that exist in the tree tree and new nodes = pair (exists, new)
  • result of updating nodes exists in tree tree with parent index index and parent distance distance = updated

  then result of adding or updating children pairs of the node at backwards index index in tree tree = result of pushing nodes new into tree updated where parent is index and parent distance is distance

  (link)

Comments

Please log in to add comments