Mutate my DNA sequence When translating DNA into proteins, the ribosomes read the sequence of DNA nucleotides 3 by 3. Each set of 3 nucleotides is called a codon, and each codon encodes for an amino acid, with some redundancies. Here's the conversion table used by most organisms (table is read left, top, right):

Humans and most other organisms use just a single amino acid as a &quot;start&quot; codon: Methionine, a.k.a. Met, M, or ATG. This means that any DNA sequence coding for a protein starts with ATG, which will be recognised by the translation machinery.
However, three different codons are used to stop the translation: TAA, TAG and TGA. If the replication machinery encounters any of these, it will stop, and the translated protein will be released into the cell.
Therefore, one of the most dangerous mutations that can occur is one that will cause an early termination of protein translation. For example, if we take this DNA sequence:
ATGGCCTTCATATCGGCGGACAGCGAATCTGGTGATTAA
Split into codons:
ATG GCC TTC ATA TCG GCG GAC AGC GAA TCT GGT GAT TAA
Once translated, will give:
met ala phe ile ser ala asp ser glu ser gly asp STOP
But if we replace C at 14th position into an A, then the protein sequence will be
met ala phe ile STOP
This substitution would be written in genomics as 14C&gt;A.
I could also perform other substitutions (25G&gt;T for example) that would cause early termination, but 14C&gt;A is the first one in the sequence, and so would produce the shortest protein after translation.
Challenge
Given a string of nucleotides coding for a protein (first codon is ATG, last is a STOP), find the first substitution that would cause an early termination of protein translation, resulting in the shortest possible protein. This is code golf, so fewest bytes wins!
Rules and specifications
(these will be updated if anyone asks relevant questions about what's allowed)

DNA sequence is stored in a character string as consecutive block capitals, no spaces or punctuation in it, and contains only ACGT. If you want to store it into binary (A:00/C:01/G:10/T:11) or as integers (A:1/C:2/G:3/T:4), that's fine (you don't need to follow these encodings).

Declaration of the codon to amino acid conversion table is part of the golfing challenge. You must choose which parts you deem relevant. Most softwares use hashes / dictionaries to store it.

Code should return the substitution formatted under the preferred nomenclature: 14C&gt;A (position, original nucleotide, &quot;&gt;&quot;, new nucleotide), but any format that includes those three elements is accepted.

If there are no possible early termination sites, function should return any easily recognisable error value (raise an error, FALSE, -1, etc) or return nothing.


Test cases
ATGCACTGTTGGGGAGGCAGCTGTAACTCAAAGCCTTAG
-&gt; 9T&gt;A

ATGGTAGAACGGAGCAGCTGGTCATGTGTGGGCCCACCGGCCCCAGGCTCCTGTCTCCCCCCAGGTGTGTGGTCATGCCAGGCATGCCCTTAG
-&gt; 7G&gt;T

ATGGAACATCAATCTCAGGCACCTGGCCCAGGTCATTAA
-&gt; 4G&gt;T

ATGTGCCAAGTGCATTCTTGTGTGCTTGCATCTCATGGAACGCCATTTCCCCAGACATCCCTGTGGCTGGCTCCTGATGCCCGAGGCCCATGA
-&gt; 6C&gt;A

ATGCTTTTCCATGTTCTTTGGCCGCAGCAAGGCCGCTCTCACTGCAAAGTTAACTCTGATGCGTGA
-&gt; 20G&gt;A

ATGGTAGAGTAA
-&gt; 7G&gt;T

ATGGTTCCACGGTAA
-&gt; ERROR
JavaScript (ES6), &nbsp;124 ... 93&nbsp; 92 bytes

Output format: XiY, with X = original nucleotide, i = position, Y = new nucleotide.

s=&gt;s[i=([,,x,y]=s.match(/(.A[AG]|.GA|T(.[AG]|(A|G).))(...)*$/)).index+!!x+!!y]+-~i+'AT'[+!x]


Try it online!

Regular expression

r = /(.A[AG]|.GA|T(.[AG]|(A|G).))(...)*$/
     (          |               )           // 1st capturing group
      .A[AG]|.GA                            // match ★AA, ★AG or ★GA
                 T(.[AG]|(A|G).)            // 'T' + 2nd &amp; 3rd capturing groups:
                                            // match T★A, T★G, TA★ or TG★
                                 (...)*$    // make sure that the number of trailing
                                            // nucleotides is a multiple of 3


To summarize, this will match 21 codons that can be mutated to generate a STOP. By testing the 2nd and 3rd capturing groups, we can classify them into 3 categories describing the position of the nucleotide that needs to be altered.

 2nd group | 3rd group | position | matching codons
-----------+-----------+----------+-------------------------------------------------------
  not set  |  not set  |    1st   | (TAA) (TAG) (TGA) CAA CAG CGA AAA AAG AGA GAA GAG GGA
    set    |  not set  |    2nd   | TTA TTG TCA TCG TGG
    set    |    set    |    3rd   | TAT TAC TGT TGC


Commented

s =&gt;               // s = input DNA sequence
  s[               // append the original nucleotide ...
    i =            //   ... which is at position i (0-based)
    ( [,, x, y] =  //   x = 2nd capturing group, y = 3rd capturing group
        s.match(r) //   apply the regular expression to s
    ).index        //   get the position of the matching codon
    + !!x + !!y    //   add 2 if x and y are set, 1 if only x is set, 0 if x is not set
  ]                //
  + -~i            // append the 1-indexed position
  + 'AT'[+!x]      // append the new nucleotide: 'T' if x is not set, 'A' otherwise