Jumping to an integer variable that had not been ASSIGNed to was unfortunately possible, and was a major source of bugs involving assigned gotos. The Fortran codice_43 statement only allows a constant (existing) line number to be assigned to the integer variable. However, it was possible to accidentally treat this variable as an integer thereafter, for example increment it, resulting in unspecified behavior at codice_1 time. The following code demonstrates the behavior of the codice_45 when line i is unspecified: 200 write(*,*) "this is valid line number" Several C compilers implement two non-standard C/C++ extensions relating to gotos originally introduced by gcc. The GNU extension allows the address of a label inside the current function to be obtained as a codice_46 using the unary, prefix label value operator codice_47. The goto instruction is also extended to allow jumping to an arbitrary codice_46 expression. This C extension is referred to as a "computed goto" in documentation of the C compilers that support it; its semantics are a superset of Fortran's assigned goto, because it allows arbitrary pointer expressions as the goto target, while Fortran's assigned goto doesn't allow arbitrary expressions as jump target. As with the standard goto in C, the GNU C extension allows the target of the computed goto to reside only in the current function. Attempting to jump outside the current function results in unspecified behavior. Some variants of BASIC also support a computed GOTO in the sense used in GNU C, i.e. in which the target can be "any" line number, not just one from a list. For example, in MTS BASIC one could write codice_49 to jump to the line numbered 1000 times the value of a variable "i" (which might represent a selected menu option, for example). PL/I "label variables" achieve the effect of computed or assigned codice_39s. Up to the 1985 ANSI COBOL standard had the ALTER verb which could be used to change the destination of an existing GO TO, which had to be in a paragraph by itself. The feature, which allowed polymorphism, was frequently condemned and seldom used. In Perl, there is a variant of the codice_1 statement that is not a traditional GOTO statement at all. It takes a function name and transfers control by effectively substituting one function call for another (a tail call): the new function will not return to the GOTO, but instead to the place from which the original function was called.