code debug_program(program& current_program, const script& current_script)
{
    code ec;

    // Check if script is valid.
    // Trailing invalid op due to push op size mismatch
    // Script is unspendable (op_return / > max_script_size of 10kb)
    if (!current_program.is_valid())
        return error::invalid_script;

    // Script is valid:

    // Run individual operations of script.
    int script_index(0);

    // Loop through all script operations.
    for (const auto& op: current_program)
    {
        // Max script element size (520 bytes)
        if (op.is_oversized())
            return error::invalid_push_data_size;

        // Disallowed operations which can cause script vulnerabilities.
        if (op.is_disabled())
            return error::op_disabled;

        // Increment operation count for (op >= op_97),
        // Maximum count of 201 permitted.
        if (!current_program.increment_operation_count(op))
            return error::invalid_operation_count;

        // If operation is unconditional, conditional state must be positive
        // for subsequent operation.
        if (current_program.if_(op))
        {
            // Check that stack < 1000 elements (overflow).
            if (!current_program.is_stack_overflow())
            {
                // Execute operation. Changes state of stack.
                if ((ec = current_program.evaluate(op)))
                    return ec;

                // Print out operator that has been executed.
                std::cout << std::endl;
                std::cout << std::string(script_index + 1, '>')
                          << " Operation: " << script_index << std::endl;
                std::cout << op.to_string(rule_fork::all_rules) << std::endl;
                std::cout << std::endl;

                // Print stack state after execution of operation.
                program program_copy(current_script, current_program);
                std::cout << std::string(script_index + 1, '>')
                          << " Stack after operation: "
                          << script_index << std::endl;

                while (!program_copy.empty())
                    std::cout << "[" << encode_base16(program_copy.pop())
                              << "]" << std::endl;

                script_index += 1;
            }
        }
    }

    // Check for no outstanding flow control operations (missing ENDIF).
    return current_program.closed() ? error::success : 
        error::invalid_stack_scope;
}

code run_p2sh_p2wpkh(const transaction& transaction, uint32_t input_index,
    uint32_t forks)
{
    // Assumes witness and previous output point set in transaction.
    auto p2sh_p2wpkh_transaction = transaction;
    auto input_script = p2sh_p2wpkh_transaction.inputs()[input_index].script();
    auto witness = p2sh_p2wpkh_transaction.inputs()[input_index].witness();
    auto prevout_script = p2sh_p2wpkh_transaction.inputs()[input_index]
        .previous_output().validation.cache.script();
    auto input_amount = p2sh_p2wpkh_transaction.inputs()[input_index]
        .previous_output().validation.cache.value();

    code ec;

    // 1) Evaluate input script.
    //--------------------------------------------------------------------------

    program input_program(input_script, p2sh_p2wpkh_transaction,
        input_index, forks);
    std::cout << "=========== Input script evaluation ==========="
              << std::endl;
    if ((ec = debug_program(input_program, input_script)))
        return ec;

    // 2) Evaluate output script.
    //--------------------------------------------------------------------------

    program output_program(prevout_script, input_program);
    std::cout << "\n"
              << "=========== Output script evaluation =========="
              << std::endl;
    if ((ec = debug_program(output_program, prevout_script)))
        return ec;

    // 3) Evaluate stack after input/output run.
    //--------------------------------------------------------------------------

    if (!output_program.stack_result(false))
        return error::stack_false;

    // 4) Check for p2w pattern.
    //--------------------------------------------------------------------------

    auto witnessed = false;

    if ((forks & rule_fork::bip141_rule) != 0)
    {
        if ((witnessed = script::is_witness_program_pattern(
            prevout_script.operations())))
        {
            // Omitted: Evaluate witness program
        }
    }

    // 5) Detect P2SH pattern in output script (BIP16)
    //--------------------------------------------------------------------------

    if ((forks & rule_fork::bip16_rule) == 0))
        return error::success;

    if (prevout_script.output_pattern() == script_pattern::pay_script_hash)
    {
        std::cout << "\n"
                  << "----------- P2SH pattern detected -------------"
                  << std::endl;

        // Valid embedded script push in input script.
        if (!script::is_relaxed_push(input_script.operations()))
            return error::invalid_script_embed;

        // Extract embedded script at the top of the stack.
        script embedded_script(input_program.pop(), false);
        program embedded_program(embedded_script, std::move(input_program), true);

        std::cout << "\n"
                  << "======= P2SH Embedded script evaluation ======="
                  << std::endl;

        if ((ec = debug_program(embedded_program, embedded_script)))
            return ec;

        if (!embedded_program.stack_result(false))
            return error::stack_false;

    // 6) Detect witness program pattern in P2SH embedded script (bip141)
    //----------------------------------------------------------------------

        if ((forks & rule_fork::bip141_rule) == 0)
            return error::success;

        if ((witnessed = script::is_witness_program_pattern(
            embedded_script.operations())))
        {
            std::cout << "\n"
                      << "---------- Witness program detected -----------"
                      << std::endl;

            // 7) Extract and run extracted witness program script.
            //--------------------------------------------------------------

            // The input script must be a push of the embedded_script (bip141).
            if (input_script.size() != 1)
                return error::dirty_witness;

            const auto version = embedded_script.version();

            // Detect version 0 of witness program.
            if (version == script_version::zero)
            {
                script script;
                data_stack stack;

                if (!witness.extract_embedded_script(script, stack,
                    embedded_script))
                    return error::invalid_witness;

                std::cout
                    << "\n"
                    << "============== Witness evaluation ============="
                    << std::endl;

                program witness(script, p2sh_p2wpkh_transaction, input_index,
                    forks, std::move(stack), input_amount,
                    version);

                if ((ec = debug_program(witness, script)))
                    return ec;

                if (!witness.stack_result(false))
                    return error::stack_false;
            }
        }
    }

// Witness must be empty
return (witnessed || witness.empty()) ? error::success :
    error::unexpected_witness;
}