anchor.diff:        // Fallback to processing individual arguments.
         if (branch.argumentDifference.isNotEmpty) {
           outputBranch.arguments = await Future.wait(branch.argumentDifference
  -            .map((arg) => resolveTreeDiff(s, arg, computableIds)));
  +            .map((arg) => resolveTreeDiff(s, arg, computableIds, compute)));
           outputBranch.resolved =
               outputBranch.arguments.every((arg) => arg.resolved);
         }
  
positive.code:       outputBranch.resolved = true;
        return outputBranch;
      } else {
        // Search for a rule.
        // Rule searching parameters:
        final exprParams = [
          ARRAY(branch.left.toArray(), 'integer'),
          ARRAY(branch.right.toArray(), 'integer')
        ];
        final ruleParams = [SQL('left_array_data'), SQL('right_array_data')];
        final computableIdsArray = ARRAY(computableIds, 'integer');
  
negative.code:       ..different = true
        ..resolved = false;
    } else {
      // Get computable functions.
      final comp = await _loadComputableFunctions(s);
      final computableIds = '+-*~'.split('').map((c) => comp[c]).toList();
      final compute = (int id, List<num> args) => _exprCompute(id, args, comp);
      return await resolveTreeDiff(s, result.branch, computableIds, compute);
    }
  }
  
  Future<DifferenceBranch> resolveTreeDiff(Session s, ExprDiffBranch branch,
      List<int> computableIds, ExprCompute compute) async {
    final outputBranch = new DifferenceBranch()
      ..position = branch.position
      ..leftData = branch.left.toBase64()
  