From the definition: :$h \left({n_1, n_2, \ldots, n_k}\right) = f \left({g_1 \left({n_1, n_2, \ldots, n_k}\right), g_2 \left({n_1, n_2, \ldots, n_k}\right), \ldots, g_t \left({n_1, n_2, \ldots, n_k}\right)}\right)$. Let $P, Q_1, Q_2, \ldots, Q_t$ be normalized URM programs which compute $f, g_1, g_2, \ldots, g_t$ respectively. Let $u = \max \left\{{\rho \left({P}\right), \rho \left({Q_1}\right), \rho \left({Q_2}\right), \ldots, \rho \left({Q_t}\right)}\right\}$. Let $s_j = \lambda \left({Q_j}\right)$ be the number of basic instructions in $Q_j$ for $1 \le j \le t$. Hence: * registers $R_{u+1}, R_{u+2}, \ldots, R_{u+k}$ can be used to hold a copy of the input $\left({n_1, n_2, \ldots, n_k}\right)$ so it can be guaranteed not to be accidentally overwritten by any operations performed by any of $P, Q_1, Q_2, \ldots, Q_t$; * registers $R_{u+k+1}, R_{u+k+2}, \ldots, R_{u+k+t}$ can be used to hold copies of the outputs of each of $Q_1, Q_2, \ldots, Q_t$ so they also can be guaranteed not to be accidentally overwritten by any operations performed by any of $P, Q_1, Q_2, \ldots, Q_t$. The following algorithm can be followed to create a URM program $H$ to compute $h$. It is assumed that: * The input is in $R_1, R_2, \ldots, R_k$. * Each of $P, Q_1, Q_2, \ldots, Q_t$ are written so as to start at line $1$. {| border="1" |- ! align="right" | Step !! ! align="left" | Process ! align="left" | Notes |- | align="right" | $1$ || | align="left" | Append a Block Copy Program $C \left({1, u+1, k}\right)$ to $H$<ref>$H$, at this point, is a null URM program. After this step $\lambda \left({H}\right) = k$.</ref>. | This stores the input somewhere safe so it can be accessed again later. |- | align="right" | $2$ || | align="left" | Set $i = 1$. | This counts how many times we iterate through the following loop. |- | align="right" | $3$ || | align="left" | Calculate $l = \lambda \left({H}\right)$. | This is the length of $H$ so far. |- | align="right" | $4$ || | align="left" | Append a Block Copy Program $C \left({u+1, 1, k}\right)$ to $H$. | This restores the input that we saved in step $1$ so it will be ready for program $Q_i$<ref>The first time through $H$, this step is technically unneeded, as $R_1, R_2, \ldots, R_k$ already contains the input. However, performing this step in ''all'' cases keeps the algorithm simpler and more modular. It's a programmer thing.</ref>. |- | align="right" | $5$ || | align="left" | Increment the <tt>Jump</tt>s in $Q_i$ by $l$ lines<ref>To '''increment the <tt>Jump</tt>s by $r$''' for any normalized URM program is done by changing all <tt>Jump</tt>s of the form $J \left({m, n, q}\right)$ to $J \left({m, n, q+r}\right)$.</ref>. Call this amended version $Q_i'$. | As $Q_i$ was written so as to start from line 1, we need to move all the <tt>Jump</tt>s so as to point to the same lines relative to the start of $Q_i'$. |- | align="right" | $6$ || | align="left" | Append $Q_i'$ to $H$. | So $\lambda \left({H}\right)$ increases by $s_i$. |- | align="right" | $7$ || | align="left" | Append the command $C \left({1, u+k+i}\right)$ to $H$. | This stores the output of $Q_i'$ in a safe place where it won't get overwritten by something else. |- | align="right" | $8$ || | align="left" | Add $1$ to $i$. |  |- | align="right" | $9$ || | align="left" | Is $i \le t$? If so, go to step $3$. Otherwise, continue to the next step. | |- | align="right" | $10$ || | align="left" | Append the Block Copy Program $C \left({u+k+1, 1, t}\right)$ to $H$. | This copies the outputs of $Q_1, Q_2, \ldots, Q_t$ back into $R_1, R_2, \ldots, R_t$ ready to be the input to program $P$. |- | align="right" | $11$ || | align="left" | Calculate $l = \lambda \left({H}\right)$. | This is the length of $H$ so far. |- | align="right" | $12$ || | align="left" | Increment the <tt>Jump</tt>s in $P$ by $l$ lines. Call this amended version $P'$. | |- | align="right" | $13$ || | align="left" | Append $P'$ to $H$. | At this point, $\lambda \left({H}\right) = k + \sum_{j=1}^t \left({k + s_j + 1}\right) + t + \lambda \left({P}\right)$. |} It can easily be determined that $H$ computes $h$. Hence $h$ is URM computable. {{qed}}