The key distinction to note is the one between specifications and implementations.<p>As a small example, consider Brainfuck. The Brainfuck specification (if such a thing exists) has no upper bound on the number of memory cells, but practical implementations generally <i>do</i> have a limit that &quot;useful&quot; Brainfuck programs will rarely hit. The specification describes a TC language, while the implementation does not.<p>Therefore, if a language is TC according to its specification, but has an implementation in a language that is shown to <i>not</i> be TC, then it follows that the implementation must be of a non-TC subset of the language. This is, of course, assuming both that the specification has been proven TC, and that the implementing language has been proven non-TC.<p>I believe the point being made in the paper is that the C specification itself is restrictive enough that it describes a non-TC language. In other words, any implementation of C that is truly Turing complete would be violating the specification in some way. In that case, it follows that a C implementation of a TC language (such as the bignum language) must only be an implementation of a non-TC subset of the language.<p>(As an aside, consider that nothing running on an isolated machine will ever be truly TC, since an isolated machine has a finite amount of memory and so can&#x27;t be TC. It&#x27;s not that much of an inferential jump to see that this kind of TC-breaking limitation could end up in the specification of C, a language quite close to the metal.)