/* Function: p7_GOATrace()
* Synopsis: Optimal accuracy decoding: traceback.
* Incept: SRE, Fri Feb 29 12:59:11 2008 [Janelia]
*
* Purpose: The traceback stage of the optimal accuracy decoding algorithm
* \citep{Kall05}.
*
* Caller provides the OA DP matrix <gx> that was just
* calculated by <p7_GOptimalAccuracy()>, as well as the
* posterior decoding matrix <pp>, which was calculated by
* Forward/Backward on a target sequence of length <L>
* using the query model <gm>.
*
* Caller provides an empty traceback structure <tr> to
* hold the result, allocated to hold optional posterior
* probability annotation on residues (with
* <p7_trace_CreateWithPP()>, generally). This will be
* internally reallocated as needed for larger traces.
*
* Args: gm - query profile
* pp - posterior decoding matrix created by <p7_PosteriorDecoding()>
* gx - OA DP matrix calculated by <p7_OptimalAccuracyDP()>
* tr - RESULT: OA traceback, allocated with posterior probs
*
* Returns: <eslOK> on success, and <tr> contains the OA traceback.
*
* Throws: <eslEMEM> on allocation error.
*/
int
p7_GOATrace(const P7_PROFILE *gm, const P7_GMX *pp, const P7_GMX *gx, P7_TRACE *tr)
{
int i = gx->L; /* position in seq (1..L) */
int k = 0; /* position in model (1..M) */
float postprob;
int sprv, scur;
int status;
#ifdef p7_DEBUGGING
if (tr->N != 0) ESL_EXCEPTION(eslEINVAL, "trace isn't empty: forgot to Reuse()?");
#endif
if ((status = p7_trace_AppendWithPP(tr, p7T_T, k, i, 0.0)) != eslOK) return status;
if ((status = p7_trace_AppendWithPP(tr, p7T_C, k, i, 0.0)) != eslOK) return status;
sprv = p7T_C;
while (sprv != p7T_S)
{
switch (sprv) {
case p7T_M: scur = select_m(gm, gx, i, k); k--; i--; break;
case p7T_D: scur = select_d(gm, gx, i, k); k--; break;
case p7T_I: scur = select_i(gm, gx, i, k); i--; break;
case p7T_N: scur = select_n(i); break;
case p7T_C: scur = select_c(gm, pp, gx, i); break;
case p7T_J: scur = select_j(gm, pp, gx, i); break;
case p7T_E: scur = select_e(gm, gx, i, &k); break;
case p7T_B: scur = select_b(gm, gx, i); break;
default: ESL_EXCEPTION(eslEINVAL, "bogus state in traceback");
}
if (scur == -1) ESL_EXCEPTION(eslEINVAL, "OA traceback choice failed");
postprob = get_postprob(pp, scur, sprv, k, i);
if ((status = p7_trace_AppendWithPP(tr, scur, k, i, postprob)) != eslOK) return status;
/* For NCJ, we had to defer i decrement. */
if ( (scur == p7T_N || scur == p7T_J || scur == p7T_C) && scur == sprv) i--;
sprv = scur;
}
tr->M = gm->M;
tr->L = gx->L;
return p7_trace_Reverse(tr);
}
/* Function: p7_StochasticTrace()
* Synopsis: Sample a traceback from a Forward matrix
* Incept: SRE, Fri Aug 8 17:40:18 2008 [UA217, IAD-SFO]
*
* Purpose: Perform a stochastic traceback from Forward matrix <ox>,
* using random number generator <r>, in order to sample an
* alignment of model <om> to digital sequence <dsq> of
* length <L>.
*
* The sampled traceback is returned in <tr>, which the
* caller provides with at least an initial allocation;
* the <tr> allocation will be grown as needed here.
*
* Args: r - source of random numbers
* dsq - digital sequence being aligned, 1..L
* L - length of dsq
* om - profile
* ox - Forward matrix to trace, LxM
* tr - storage for the recovered traceback
*
* Returns: <eslOK> on success
*
* Throws: <eslEMEM> on allocation error.
* <eslEINVAL> on several types of problems, including:
* the trace isn't empty (wasn't Reuse()'d);
*/
int
p7_StochasticTrace(ESL_RANDOMNESS *rng, const ESL_DSQ *dsq, int L, const P7_OPROFILE *om, const P7_OMX *ox,
P7_TRACE *tr)
{
int i; /* position in sequence 1..L */
int k; /* position in model 1..M */
int s0, s1; /* choice of a state */
int status;
if (tr->N != 0) ESL_EXCEPTION(eslEINVAL, "trace not empty; needs to be Reuse()'d?");
i = L;
k = 0;
if ((status = p7_trace_Append(tr, p7T_T, k, i)) != eslOK) return status;
if ((status = p7_trace_Append(tr, p7T_C, k, i)) != eslOK) return status;
s0 = tr->st[tr->N-1];
while (s0 != p7T_S)
{
switch (s0) {
case p7T_M: s1 = select_m(rng, om, ox, i, k); k--; i--; break;
case p7T_D: s1 = select_d(rng, om, ox, i, k); k--; break;
case p7T_I: s1 = select_i(rng, om, ox, i, k); i--; break;
case p7T_N: s1 = select_n(i); break;
case p7T_C: s1 = select_c(rng, om, ox, i); break;
case p7T_J: s1 = select_j(rng, om, ox, i); break;
case p7T_E: s1 = select_e(rng, om, ox, i, &k); break;
case p7T_B: s1 = select_b(rng, om, ox, i); break;
default: ESL_EXCEPTION(eslEINVAL, "bogus state in traceback");
}
if (s1 == -1) ESL_EXCEPTION(eslEINVAL, "Stochastic traceback choice failed");
if ((status = p7_trace_Append(tr, s1, k, i)) != eslOK) return status;
if ( (s1 == p7T_N || s1 == p7T_J || s1 == p7T_C) && s1 == s0) i--;
s0 = s1;
} /* end traceback, at S state */
tr->M = om->M;
tr->L = L;
return p7_trace_Reverse(tr);
}
/* Function: p7_OATrace()
* Synopsis: Optimal accuracy decoding: traceback.
* Incept: SRE, Mon Aug 18 13:53:33 2008 [Janelia]
*
* Purpose: The traceback stage of the optimal accuracy decoding algorithm
* \citep{Kall05}.
*
* Caller provides the OA DP matrix <ox> that was just
* calculated by <p7_OptimalAccuracyDP()>, as well as the
* posterior decoding matrix <pp>, which was calculated by
* Forward/Backward on a target sequence using the query
* model <gm>. Because the calculation depends only on
* <pp>, the target sequence itself need not be provided.
*
* The resulting optimal accuracy decoding traceback is put
* in a caller-provided traceback structure <tr>, which the
* caller has allocated for optional posterior probability
* annotation on residues (with <p7_trace_CreateWithPP()>,
* generally). This structure will be reallocated
* internally if necessary.
*
* Args: om - profile
* pp - posterior probability matrix
* ox - OA matrix to trace, LxM
* tr - storage for the recovered traceback
*
* Returns: <eslOK> on success.
*
* Throws: <eslEMEM> on allocation error.
* <eslEINVAL> if the trace <tr> isn't empty (needs to be Reuse()'d).
*/
int
p7_OATrace(const P7_OPROFILE *om, const P7_OMX *pp, const P7_OMX *ox, P7_TRACE *tr)
{
int i = ox->L; /* position in sequence 1..L */
int k = 0; /* position in model 1..M */
int s0, s1; /* choice of a state */
float postprob;
int status;
if (tr->N != 0) ESL_EXCEPTION(eslEINVAL, "trace not empty; needs to be Reuse()'d?");
if ((status = p7_trace_AppendWithPP(tr, p7T_T, k, i, 0.0)) != eslOK) return status;
if ((status = p7_trace_AppendWithPP(tr, p7T_C, k, i, 0.0)) != eslOK) return status;
s0 = tr->st[tr->N-1];
while (s0 != p7T_S)
{
switch (s0) {
case p7T_M: s1 = select_m(om, ox, i, k); k--; i--; break;
case p7T_D: s1 = select_d(om, ox, i, k); k--; break;
case p7T_I: s1 = select_i(om, ox, i, k); i--; break;
case p7T_N: s1 = select_n(i); break;
case p7T_C: s1 = select_c(om, pp, ox, i); break;
case p7T_J: s1 = select_j(om, pp, ox, i); break;
case p7T_E: s1 = select_e(om, ox, i, &k); break;
case p7T_B: s1 = select_b(om, ox, i); break;
default: ESL_EXCEPTION(eslEINVAL, "bogus state in traceback");
}
if (s1 == -1) ESL_EXCEPTION(eslEINVAL, "OA traceback choice failed");
postprob = get_postprob(pp, s1, s0, k, i);
if ((status = p7_trace_AppendWithPP(tr, s1, k, i, postprob)) != eslOK) return status;
if ( (s1 == p7T_N || s1 == p7T_J || s1 == p7T_C) && s1 == s0) i--;
s0 = s1;
} /* end traceback, at S state */
tr->M = om->M;
tr->L = ox->L;
return p7_trace_Reverse(tr);
}
/* Function: p7_GStochasticTrace()
* Synopsis: Stochastic traceback of a Forward matrix.
* Incept: SRE, Thu Jan 3 15:39:20 2008 [Janelia]
*
* Purpose: Stochastic traceback of Forward matrix <gx> to
* sample an alignment of digital sequence <dsq>
* (of length <L>) to the profile <gm>.
*
* The sampled traceback is returned in <tr>, which the
* caller must have at least made an initial allocation of
* (the <tr> will be grown as needed here).
*
* Args: r - source of random numbers
* dsq - digital sequence aligned to, 1..L
* L - length of dsq
* gm - profile
* mx - Forward matrix to trace, L x M
* tr - storage for the recovered traceback.
*
* Returns: <eslOK> on success.
*/
int
p7_GStochasticTrace(ESL_RANDOMNESS *r, const ESL_DSQ *dsq, int L, const P7_PROFILE *gm, const P7_GMX *gx, P7_TRACE *tr)
{
int status;
int i; /* position in seq (1..L) */
int k; /* position in model (1..M) */
int M = gm->M;
float **dp = gx->dp;
float *xmx = gx->xmx;
float const *tsc = gm->tsc;
float *sc; /* scores of possible choices: up to 2M-1, in the case of exits to E */
int scur, sprv;
/* we'll index M states as 1..M, and D states as 2..M = M+2..2M: M0, D1 are impossibles. */
ESL_ALLOC(sc, sizeof(float) * (2*M+1));
k = 0;
i = L;
if ((status = p7_trace_Append(tr, p7T_T, k, i)) != eslOK) goto ERROR;
if ((status = p7_trace_Append(tr, p7T_C, k, i)) != eslOK) goto ERROR;
sprv = p7T_C;
while (sprv != p7T_S)
{
switch (tr->st[tr->N-1]) {
/* C(i) comes from C(i-1) or E(i) */
case p7T_C:
if (XMX(i,p7G_C) == -eslINFINITY) ESL_XEXCEPTION(eslFAIL, "impossible C reached at i=%d", i);
sc[0] = XMX(i-1, p7G_C) + gm->xsc[p7P_C][p7P_LOOP];
sc[1] = XMX(i, p7G_E) + gm->xsc[p7P_E][p7P_MOVE];
esl_vec_FLogNorm(sc, 2);
scur = (esl_rnd_FChoose(r, sc, 2) == 0) ? p7T_C : p7T_E;
break;
/* E connects from any M or D state. k set here */
case p7T_E:
if (XMX(i, p7G_E) == -eslINFINITY) ESL_XEXCEPTION(eslFAIL, "impossible E reached at i=%d", i);
if (p7_profile_IsLocal(gm)) { /* local models come from any M, D */
sc[0] = sc[M+1] = -eslINFINITY;
for (k = 1; k <= M; k++) sc[k] = MMX(i,k);
for (k = 2; k <= M; k++) sc[k+M] = DMX(i,k);
esl_vec_FLogNorm(sc, 2*M+1); /* now sc is a prob vector */
k = esl_rnd_FChoose(r, sc, 2*M+1);
if (k <= M) scur = p7T_M;
else { k -= M; scur = p7T_D; }
} else { /* glocal models come from M_M or D_M */
k = M;
sc[0] = MMX(i,M);
sc[1] = DMX(i,M);
esl_vec_FLogNorm(sc, 2); /* now sc is a prob vector */
scur = (esl_rnd_FChoose(r, sc, 2) == 0) ? p7T_M : p7T_D;
}
break;
/* M connects from {MDI} i-1,k-1, or B */
case p7T_M:
if (MMX(i,k) == -eslINFINITY) ESL_XEXCEPTION(eslFAIL, "impossible M reached at k=%d,i=%d", k,i);
sc[0] = XMX(i-1,p7G_B) + TSC(p7P_BM, k-1);
sc[1] = MMX(i-1,k-1) + TSC(p7P_MM, k-1);
sc[2] = IMX(i-1,k-1) + TSC(p7P_IM, k-1);
sc[3] = DMX(i-1,k-1) + TSC(p7P_DM, k-1);
esl_vec_FLogNorm(sc, 4);
switch (esl_rnd_FChoose(r, sc, 4)) {
case 0: scur = p7T_B; break;
case 1: scur = p7T_M; break;
case 2: scur = p7T_I; break;
case 3: scur = p7T_D; break;
}
k--;
i--;
break;
/* D connects from M,D at i,k-1 */
case p7T_D:
if (DMX(i, k) == -eslINFINITY) ESL_XEXCEPTION(eslFAIL, "impossible D reached at k=%d,i=%d", k,i);
sc[0] = MMX(i, k-1) + TSC(p7P_MD, k-1);
sc[1] = DMX(i, k-1) + TSC(p7P_DD, k-1);
esl_vec_FLogNorm(sc, 2);
scur = (esl_rnd_FChoose(r, sc, 2) == 0) ? p7T_M : p7T_D;
k--;
break;
/* I connects from M,I at i-1,k */
case p7T_I:
if (IMX(i,k) == -eslINFINITY) ESL_XEXCEPTION(eslFAIL, "impossible I reached at k=%d,i=%d", k,i);
sc[0] = MMX(i-1,k) + TSC(p7P_MI, k);
sc[1] = IMX(i-1,k) + TSC(p7P_II, k);
esl_vec_FLogNorm(sc, 2);
scur = (esl_rnd_FChoose(r, sc, 2) == 0) ? p7T_M : p7T_I;
i--;
break;
/* N connects from S, N */
case p7T_N:
if (XMX(i, p7G_N) == -eslINFINITY) ESL_XEXCEPTION(eslFAIL, "impossible N reached at i=%d", i);
scur = (i == 0) ? p7T_S : p7T_N;
break;
/* B connects from N, J */
case p7T_B:
if (XMX(i,p7G_B) == -eslINFINITY) ESL_XEXCEPTION(eslFAIL, "impossible B reached at i=%d", i);
sc[0] = XMX(i, p7G_N) + gm->xsc[p7P_N][p7P_MOVE];
sc[1] = XMX(i, p7G_J) + gm->xsc[p7P_J][p7P_MOVE];
esl_vec_FLogNorm(sc, 2);
scur = (esl_rnd_FChoose(r, sc, 2) == 0) ? p7T_N : p7T_J;
break;
/* J connects from E(i) or J(i-1) */
case p7T_J:
if (XMX(i,p7G_J) == -eslINFINITY) ESL_XEXCEPTION(eslFAIL, "impossible J reached at i=%d", i);
sc[0] = XMX(i-1,p7G_J) + gm->xsc[p7P_J][p7P_LOOP];
sc[1] = XMX(i, p7G_E) + gm->xsc[p7P_E][p7P_LOOP];
esl_vec_FLogNorm(sc, 2);
scur = (esl_rnd_FChoose(r, sc, 2) == 0) ? p7T_J : p7T_E;
break;
default: ESL_XEXCEPTION(eslFAIL, "bogus state in traceback");
} /* end switch over statetype[tpos-1] */
/* Append this state and the current i,k to be explained to the growing trace */
if ((status = p7_trace_Append(tr, scur, k, i)) != eslOK) goto ERROR;
/* For NCJ, we had to defer i decrement. */
if ( (scur == p7T_N || scur == p7T_J || scur == p7T_C) && scur == sprv) i--;
sprv = scur;
} /* end traceback, at S state */
if ((status = p7_trace_Reverse(tr)) != eslOK) goto ERROR;
tr->M = gm->M;
tr->L = L;
free(sc);
return eslOK;
ERROR:
if (sc != NULL) free(sc);
return status;
}
/* Function: p7_GTrace()
* Incept: SRE, Thu Feb 1 10:25:56 2007 [UA 8018 St. Louis to Dulles]
*
* Purpose: Traceback of a Viterbi matrix: retrieval
* of optimum alignment.
*
* This function is currently implemented as a
* reconstruction traceback, rather than using a shadow
* matrix. Because H3 uses floating point scores, and we
* can't compare floats for equality, we have to compare
* floats for near-equality and therefore, formally, we can
* only guarantee a near-optimal traceback. However, even in
* the unlikely event that a suboptimal is returned, the
* score difference from true optimal will be negligible.
*
* Args: dsq - digital sequence aligned to, 1..L
* L - length of <dsq>
* gm - profile
* mx - Viterbi matrix to trace, L x M
* tr - storage for the recovered traceback.
*
* Return: <eslOK> on success.
* <eslFAIL> if even the optimal path has zero probability;
* in this case, the trace is set blank (<tr->N = 0>).
*
* Note: Care is taken to evaluate the prev+tsc+emission
* calculations in exactly the same order that Viterbi did
* them, lest you get numerical problems with
* a+b+c = d; d-c != a+b because d,c are nearly equal.
* (This bug appeared in dev: xref J1/121.)
*/
int
p7_GTrace(const ESL_DSQ *dsq, int L, const P7_PROFILE *gm, const P7_GMX *gx, P7_TRACE *tr)
{
int i = L; /* position in seq (1..L) */
int k = 0; /* position in model (1..M) */
int M = gm->M;
float **dp = gx->dp; /* so {MDI}MX() macros work */
float *xmx = gx->xmx; /* so XMX() macro works */
float tol = 1e-5; /* floating point "equality" test */
float const *tsc = gm->tsc;
int sprv, scur; /* previous, current state in trace */
int status;
#ifdef p7_DEBUGGING
if (tr->N != 0) ESL_EXCEPTION(eslEINVAL, "trace isn't empty: forgot to Reuse()?");
#endif
if ((status = p7_trace_Append(tr, p7T_T, k, i)) != eslOK) return status;
if ((status = p7_trace_Append(tr, p7T_C, k, i)) != eslOK) return status;
sprv = p7T_C;
while (sprv != p7T_S) {
float const *rsc = (i>0 ? gm->rsc[dsq[i]] : NULL);
switch (sprv) {
case p7T_C: /* C(i) comes from C(i-1) or E(i) */
if (XMX(i,p7G_C) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible C reached at i=%d", i);
if (esl_FCompare(XMX(i, p7G_C), XMX(i-1, p7G_C) + gm->xsc[p7P_C][p7P_LOOP], tol) == eslOK) scur = p7T_C;
else if (esl_FCompare(XMX(i, p7G_C), XMX(i, p7G_E) + gm->xsc[p7P_E][p7P_MOVE], tol) == eslOK) scur = p7T_E;
else ESL_EXCEPTION(eslFAIL, "C at i=%d couldn't be traced", i);
break;
case p7T_E: /* E connects from any M state. k set here */
if (XMX(i, p7G_E) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible E reached at i=%d", i);
if (p7_profile_IsLocal(gm))
{
scur = p7T_M; /* can't come from D, in a *local* Viterbi trace. */
for (k = M; k >= 1; k--) if (esl_FCompare(XMX(i, p7G_E), MMX(i,k), tol) == eslOK) break;
if (k == 0) ESL_EXCEPTION(eslFAIL, "E at i=%d couldn't be traced", i);
}
else /* glocal mode: we either come from D_M or M_M */
{
if (esl_FCompare(XMX(i, p7G_E), MMX(i,M), tol) == eslOK) { scur = p7T_M; k = M; }
else if (esl_FCompare(XMX(i, p7G_E), DMX(i,M), tol) == eslOK) { scur = p7T_D; k = M; }
else ESL_EXCEPTION(eslFAIL, "E at i=%d couldn't be traced", i);
}
break;
case p7T_M: /* M connects from i-1,k-1, or B */
if (MMX(i,k) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible M reached at k=%d,i=%d", k,i);
if (esl_FCompare(MMX(i,k), XMX(i-1,p7G_B) + TSC(p7P_BM, k-1) + MSC(k), tol) == eslOK) scur = p7T_B;
else if (esl_FCompare(MMX(i,k), MMX(i-1,k-1) + TSC(p7P_MM, k-1) + MSC(k), tol) == eslOK) scur = p7T_M;
else if (esl_FCompare(MMX(i,k), IMX(i-1,k-1) + TSC(p7P_IM, k-1) + MSC(k), tol) == eslOK) scur = p7T_I;
else if (esl_FCompare(MMX(i,k), DMX(i-1,k-1) + TSC(p7P_DM, k-1) + MSC(k), tol) == eslOK) scur = p7T_D;
else ESL_EXCEPTION(eslFAIL, "M at k=%d,i=%d couldn't be traced", k,i);
k--; i--;
break;
case p7T_D: /* D connects from M,D at i,k-1 */
if (DMX(i, k) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible D reached at k=%d,i=%d", k,i);
if (esl_FCompare(DMX(i,k), MMX(i, k-1) + TSC(p7P_MD, k-1), tol) == eslOK) scur = p7T_M;
else if (esl_FCompare(DMX(i,k), DMX(i, k-1) + TSC(p7P_DD, k-1), tol) == eslOK) scur = p7T_D;
else ESL_EXCEPTION(eslFAIL, "D at k=%d,i=%d couldn't be traced", k,i);
k--;
break;
case p7T_I: /* I connects from M,I at i-1,k*/
if (IMX(i,k) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible I reached at k=%d,i=%d", k,i);
if (esl_FCompare(IMX(i,k), MMX(i-1,k) + TSC(p7P_MI, k) + ISC(k), tol) == eslOK) scur = p7T_M;
else if (esl_FCompare(IMX(i,k), IMX(i-1,k) + TSC(p7P_II, k) + ISC(k), tol) == eslOK) scur = p7T_I;
else ESL_EXCEPTION(eslFAIL, "I at k=%d,i=%d couldn't be traced", k,i);
i--;
break;
case p7T_N: /* N connects from S, N */
if (XMX(i, p7G_N) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible N reached at i=%d", i);
scur = ( (i == 0) ? p7T_S : p7T_N);
break;
case p7T_B: /* B connects from N, J */
if (XMX(i,p7G_B) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible B reached at i=%d", i);
if (esl_FCompare(XMX(i,p7G_B), XMX(i, p7G_N) + gm->xsc[p7P_N][p7P_MOVE], tol) == eslOK) scur = p7T_N;
else if (esl_FCompare(XMX(i,p7G_B), XMX(i, p7G_J) + gm->xsc[p7P_J][p7P_MOVE], tol) == eslOK) scur = p7T_J;
else ESL_EXCEPTION(eslFAIL, "B at i=%d couldn't be traced", i);
break;
case p7T_J: /* J connects from E(i) or J(i-1) */
if (XMX(i,p7G_J) == -eslINFINITY) ESL_EXCEPTION(eslFAIL, "impossible J reached at i=%d", i);
if (esl_FCompare(XMX(i,p7G_J), XMX(i-1,p7G_J) + gm->xsc[p7P_J][p7P_LOOP], tol) == eslOK) scur = p7T_J;
else if (esl_FCompare(XMX(i,p7G_J), XMX(i, p7G_E) + gm->xsc[p7P_E][p7P_LOOP], tol) == eslOK) scur = p7T_E;
else ESL_EXCEPTION(eslFAIL, "J at i=%d couldn't be traced", i);
break;
default: ESL_EXCEPTION(eslFAIL, "bogus state in traceback");
} /* end switch over statetype[tpos-1] */
/* Append this state and the current i,k to be explained to the growing trace */
if ((status = p7_trace_Append(tr, scur, k, i)) != eslOK) return status;
/* For NCJ, we had to defer i decrement. */
if ( (scur == p7T_N || scur == p7T_J || scur == p7T_C) && scur == sprv) i--;
sprv = scur;
} /* end traceback, at S state */
tr->M = gm->M;
tr->L = L;
return p7_trace_Reverse(tr);
}
