public AssemblyResolution solveContextChanges(AssemblyResolvedPatterns res,
			Map<String, Long> vals) {
		for (ContextChange chg : reversedChanges) {
			if (chg instanceof ContextOp) {
				DBG.println("Current: " + res.lineToString());
				// This seems backwards. That's because we're going backwards.
				// This is the "write" location for disassembly.
				ContextOp cop = (ContextOp) chg;
				DBG.println("Handling context change: " + cop);

				// TODO: Is this res or subres?
				MaskedLong reqval = res.readContextOp(cop);
				if (reqval.equals(MaskedLong.UNKS)) {
					DBG.println("Doesn't affect a current requirement");
					continue; // this context change does not satisfy any requirement
				}
				DBG.println("'read' " + reqval);

				// Remove the requirement that we just read before trying to solve
				res = res.maskOut(cop);
				DBG.println("Masked out: " + res.lineToString());

				// Now, solve
				AssemblyResolution sol = factory.solveOrBackfill(cop.getPatternExpression(), reqval,
					vals, res, "Solution to " + cop);
				DBG.println("Solution: " + sol.lineToString());
				if (sol.isError()) {
					AssemblyResolvedError err = (AssemblyResolvedError) sol;
					return factory.error(err.getError(), res);
				}

				// Now, forward the new requirements to my parents.
				if (sol instanceof AssemblyResolvedPatterns) {
					AssemblyResolvedPatterns solcon = (AssemblyResolvedPatterns) sol;
					AssemblyResolvedPatterns check = res.combine(solcon);
					if (null == check) {
						return factory.error("A context change caused a conflict: " + sol, res);
					}
					res = check;
				}
				else {
					AssemblyResolvedBackfill solbf = (AssemblyResolvedBackfill) sol;
					res = res.combine(solbf);
				}
				DBG.println("Combined: " + res.lineToString());
			}
		}
		return res;
	}
Solve this constructor's context changes

<p>
Each value in {@code opvals} must either be a numeric value, e.g., an index from a varnode
list, or another {@link AssemblyResolvedPatterns} for a subconstructor operand.

<p>
It's helpful to think of the SLEIGH disassembly process here. Normally, once the appropriate
constructor has been identified (by matching patterns), its context changes are applied, and
then its operands parsed (possibly parsing subconstructor operands). Thus, {@code res} can be
thought of as the intermediate result between applying context changes and parsing operands,
except in reverse. The output of this method corresponds to the state before context changes
were applied, i.e., immediately after selecting the constructor. Thus, in reverse, the
context is solved immediately before applying the selected constructor patterns.

@param res the combined resolution requirements derived from the subconstructors
@param vals any defined symbols (usually {@code inst_start}, and {@code inst_next})
@return the resolution with context changes applied in reverse, or an error
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/plugin/assembler/sleigh/sem/AssemblyConstructorSemantic.java