[Question]
  [
I came across [SVGCaptcha](http://svgcaptcha.com/ "SVGCaptcha - generate captcha in svg"), and immediately knew it was a bad idea.
I would like you to show just how bad an idea this is by extracting the validation code from the SVG images that code produces.
---
An example image looks like this:  
[![8u4x8lf](https://i.stack.imgur.com/rmOVq.png)](https://i.stack.imgur.com/rmOVq.png)  
Here is the source of the example image:
```
<?xml version="1.0" encoding="utf-8"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
        "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
    <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve"
             width="200" height="40"
    > <rect x="0" y="0" width="200" height="40" 
        style="stroke: none; fill: none;" >
        </rect> <text style="fill: #4d9363;" x="5" y="34" font-size="20" transform="translate(5, 34) rotate(-17) translate(-5, -34)">8</text>
<text style="fill: #be8b33;" x="125" y="29" font-size="21" transform="translate(125, 29) rotate(17) translate(-125, -29)">f</text>
<text style="fill: #d561ff;" x="45" y="35" font-size="20" transform="translate(45, 35) rotate(-2) translate(-45, -35)">4</text>
<text style="fill: #3de754;" x="85" y="31" font-size="21" transform="translate(85, 31) rotate(-9) translate(-85, -31)">8</text>
<text style="fill: #5ed4bf;" x="25" y="33" font-size="22" transform="translate(25, 33) rotate(16) translate(-25, -33)">u</text>
<text style="fill: #894aee;" x="105" y="28" font-size="25" transform="translate(105, 28) rotate(9) translate(-105, -28)">1</text>
<text style="fill: #e4c437;" x="65" y="32" font-size="20" transform="translate(65, 32) rotate(17) translate(-65, -32)">x</text>
</svg>
```
---
The input is the SVG image, which is a textual format.
The only real restriction is that your code must produce the values in **the correct order**.  
The input `<text>` elements are in random order so you have to pay attention to the `x` attribute in the `<text>` tag
---
Score is the number of bytes in the code
---
Since the code currently does two transforms that cancel each-other out you can ignore them, but if you do take them in consideration, go ahead and take a 30% reduction from your score.
  
[Answer]
# [Bash](https://en.wikipedia.org/wiki/Bash_(Unix_shell)), 63 56 39 bytes
```
cat<<_|grep -o 'x=.*>'|cut -c4-|sort -n|grep -o '>.</t'|cut -c2
```
```
grep -o 'x=.*>'|cut -c4-|sort -n|grep -o '>.</t'|cut -c2
```
```
grep -o 'x=.*<'|sort -k1.4n|rev|cut -c2
```
Note: requires [`cat`](http://porkmail.org/era/unix/award.html#cat), `grep`, `sort`, `rev`, and `cut`. Takes input from stdin. The output is separated by line breaks on stdout. Make sure to press CTRL+D (not COMMAND+D on Mac) when finished entering the CAPTCHA. Input must be followed by a newline and then '\_'.
**EDIT**: Saved 13 bytes.
**EDIT 2**: Saved 20 bytes thanks to [@manatwork](https://codegolf.stackexchange.com/users/4198/manatwork)!
[Answer]
# CJam, 26 bytes
```
q"x="/2>{'"/1=i}${'>/1=c}/
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=q%22x%3D%22%2F2%3E%7B'%22%2F1%3Di%7D%24%7B'%3E%2F1%3Dc%7D%2F&input=%3C%3Fxml%20version%3D%221.0%22%20encoding%3D%22utf-8%22%3F%3E%3C!DOCTYPE%20svg%20PUBLIC%20%22-%2F%2FW3C%2F%2FDTD%20SVG%2020010904%2F%2FEN%22%0A%20%20%20%20%20%20%20%20%22http%3A%2F%2Fwww.w3.org%2FTR%2F2001%2FREC-SVG-20010904%2FDTD%2Fsvg10.dtd%22%3E%0A%20%20%20%20%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20xmlns%3Axlink%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxlink%22%20xml%3Aspace%3D%22preserve%22%0A%20%20%20%20%20%20%20%20%20%20%20%20%20width%3D%22200%22%20height%3D%2240%22%0A%20%20%20%20%3E%20%3Crect%20x%3D%220%22%20y%3D%220%22%20width%3D%22200%22%20height%3D%2240%22%20%0A%20%20%20%20%20%20%20%20style%3D%22stroke%3A%20none%3B%20fill%3A%20none%3B%22%20%3E%0A%20%20%20%20%20%20%20%20%3C%2Frect%3E%20%3Ctext%20style%3D%22fill%3A%20%234d9363%3B%22%20x%3D%225%22%20y%3D%2234%22%20font-size%3D%2220%22%20transform%3D%22translate(5%2C%2034)%20rotate(-17)%20translate(-5%2C%20-34)%22%3E8%3C%2Ftext%3E%0A%3Ctext%20style%3D%22fill%3A%20%23be8b33%3B%22%20x%3D%22125%22%20y%3D%2229%22%20font-size%3D%2221%22%20transform%3D%22translate(125%2C%2029)%20rotate(17)%20translate(-125%2C%20-29)%22%3Ef%3C%2Ftext%3E%0A%3Ctext%20style%3D%22fill%3A%20%23d561ff%3B%22%20x%3D%2245%22%20y%3D%2235%22%20font-size%3D%2220%22%20transform%3D%22translate(45%2C%2035)%20rotate(-2)%20translate(-45%2C%20-35)%22%3E4%3C%2Ftext%3E%0A%3Ctext%20style%3D%22fill%3A%20%233de754%3B%22%20x%3D%2285%22%20y%3D%2231%22%20font-size%3D%2221%22%20transform%3D%22translate(85%2C%2031)%20rotate(-9)%20translate(-85%2C%20-31)%22%3E8%3C%2Ftext%3E%0A%3Ctext%20style%3D%22fill%3A%20%235ed4bf%3B%22%20x%3D%2225%22%20y%3D%2233%22%20font-size%3D%2222%22%20transform%3D%22translate(25%2C%2033)%20rotate(16)%20translate(-25%2C%20-33)%22%3Eu%3C%2Ftext%3E%0A%3Ctext%20style%3D%22fill%3A%20%23894aee%3B%22%20x%3D%22105%22%20y%3D%2228%22%20font-size%3D%2225%22%20transform%3D%22translate(105%2C%2028)%20rotate(9)%20translate(-105%2C%20-28)%22%3E1%3C%2Ftext%3E%0A%3Ctext%20style%3D%22fill%3A%20%23e4c437%3B%22%20x%3D%2265%22%20y%3D%2232%22%20font-size%3D%2220%22%20transform%3D%22translate(65%2C%2032)%20rotate(17)%20translate(-65%2C%20-32)%22%3Ex%3C%2Ftext%3E%0A%3C%2Fsvg%3E).
### How it works
```
q     e# Read all input from STDIN.
"x="/ e# Split it at occurrences of "x=".
2>    e# Discard the first two chunks (head and container).
{     e# Sort the remaining chunks by the following key:
  '"/ e#   Split at occurrences of '"'.
  1=  e#   Select the second chunk (digits of x="<digits>").
  i   e#   Cast to integer.
}$    e#
{     e# For each of the sorted chunks:
  '>/ e#   Split at occurrences of '>'.
  1=  e#   Select the second chunk.
  c   e#   Cast to character.
}/    e#
```
[Answer]
# JavaScript, 95 93 91 bytes
```
l=[],r=/x="(\d*).*>(.)/g;while(e=r.exec(document.lastChild.innerHTML))l[e[1]]=e[2];l.join``
```
*edit: -2 bytes changing `documentRoot` to `lastChild`; -2 bytes changing `join('')` to `join```, thanks Vɪʜᴀɴ*
Enter code in the browser console on a page containg the SVG in question, writes to console output.
[Answer]
## Perl, 40 bytes
**39 bytes code + 1 for -n**
```
$a[$1]=$2 for/x="(.+)".+(.)</g}{print@a
```
### Example:
```
perl -ne '$a[$1]=$2 for/x="(.+)".+(.)</g}{print@a' <<< '<example from above>'
8u4x81f
```
[Answer]
# Bash + GNU utilities, 53
```
grep -Po '(?<=x=").*(?=<)'|sort -n|grep -Po '(?<=>).'
```
Like [this answer](https://codegolf.stackexchange.com/a/63991/11259), output is one char per line.
[Answer]
## [Perl 6](http://perl6.org), 68 bytes
```
say [~] lines.map({/'x="'(\d+).*(.)\</??(+$0=>$1)!!()}).sort».value
```
[Answer]
# Befunge, 79 bytes
It feels like it should be possible to golf at least one more byte off of this, but I've been working on it for a couple of days now, and this is as good as I could get it.
```
<%*:"~"*"~"_~&45*/99p1v-">":_|#`0:~<
#,:#g7-#:_@^-+*"x~=":+_~99g7p>999p#^_>>#1+
```
[Try it online!](http://befunge.tryitonline.net/#code=PCUqOiJ+IioifiJffiY0NSovOTlwMXYtIj4iOl98I2AwOn48CiMsOiNnNy0jOl9AXi0rKiJ4fj0iOitffjk5ZzdwPjk5OXAjXl8+PiMxKw&input=PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz48IURPQ1RZUEUgc3ZnIFBVQkxJQyAiLS8vVzNDLy9EVEQgU1ZHIDIwMDEwOTA0Ly9FTiIKICAgICAgICAiaHR0cDovL3d3dy53My5vcmcvVFIvMjAwMS9SRUMtU1ZHLTIwMDEwOTA0L0RURC9zdmcxMC5kdGQiPgogICAgPHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHhtbG5zOnhsaW5rPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIiB4bWw6c3BhY2U9InByZXNlcnZlIgogICAgICAgICAgICAgd2lkdGg9IjIwMCIgaGVpZ2h0PSI0MCIKICAgID4gPHJlY3QgeD0iMCIgeT0iMCIgd2lkdGg9IjIwMCIgaGVpZ2h0PSI0MCIgCiAgICAgICAgc3R5bGU9InN0cm9rZTogbm9uZTsgZmlsbDogbm9uZTsiID4KICAgICAgICA8L3JlY3Q+IDx0ZXh0IHN0eWxlPSJmaWxsOiAjNGQ5MzYzOyIgeD0iNSIgeT0iMzQiIGZvbnQtc2l6ZT0iMjAiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDUsIDM0KSByb3RhdGUoLTE3KSB0cmFuc2xhdGUoLTUsIC0zNCkiPjg8L3RleHQ+Cjx0ZXh0IHN0eWxlPSJmaWxsOiAjYmU4YjMzOyIgeD0iMTI1IiB5PSIyOSIgZm9udC1zaXplPSIyMSIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMTI1LCAyOSkgcm90YXRlKDE3KSB0cmFuc2xhdGUoLTEyNSwgLTI5KSI+ZjwvdGV4dD4KPHRleHQgc3R5bGU9ImZpbGw6ICNkNTYxZmY7IiB4PSI0NSIgeT0iMzUiIGZvbnQtc2l6ZT0iMjAiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDQ1LCAzNSkgcm90YXRlKC0yKSB0cmFuc2xhdGUoLTQ1LCAtMzUpIj40PC90ZXh0Pgo8dGV4dCBzdHlsZT0iZmlsbDogIzNkZTc1NDsiIHg9Ijg1IiB5PSIzMSIgZm9udC1zaXplPSIyMSIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoODUsIDMxKSByb3RhdGUoLTkpIHRyYW5zbGF0ZSgtODUsIC0zMSkiPjg8L3RleHQ+Cjx0ZXh0IHN0eWxlPSJmaWxsOiAjNWVkNGJmOyIgeD0iMjUiIHk9IjMzIiBmb250LXNpemU9IjIyIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgyNSwgMzMpIHJvdGF0ZSgxNikgdHJhbnNsYXRlKC0yNSwgLTMzKSI+dTwvdGV4dD4KPHRleHQgc3R5bGU9ImZpbGw6ICM4OTRhZWU7IiB4PSIxMDUiIHk9IjI4IiBmb250LXNpemU9IjI1IiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxMDUsIDI4KSByb3RhdGUoOSkgdHJhbnNsYXRlKC0xMDUsIC0yOCkiPjE8L3RleHQ+Cjx0ZXh0IHN0eWxlPSJmaWxsOiAjZTRjNDM3OyIgeD0iNjUiIHk9IjMyIiBmb250LXNpemU9IjIwIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSg2NSwgMzIpIHJvdGF0ZSgxNykgdHJhbnNsYXRlKC02NSwgLTMyKSI+eDwvdGV4dD4KPC9zdmc+)
**Explanation**
![Source code with execution paths highlighted](https://i.stack.imgur.com/4ozqv.png)
![*](https://i.stack.imgur.com/jmV4j.png) Make the execution direction right-to-left, and wrap around to start the main loop.  
![*](https://i.stack.imgur.com/z4eIY.png) Read a char from stdin, and test for the end-of-file value.  
![*](https://i.stack.imgur.com/RFUim.png) If it's not end-of-file, check if it's a `>`.  
![*](https://i.stack.imgur.com/BX1CZ.png) If it's not a `>`, add it to the value on the stack which tracks the last two characters, and check if the current pair matches `x=`.  
I'm glossing over some of the details here, since the code paths overlap each other in ways which are a little difficult to explain, but it should give you a general idea of how the algorithm works.
[Answer]
# Python2, 129 bytes
```
import re,sys
print''.join(t[1] for t in sorted(re.findall(r'(\d+), -\d+\)"\>(.)\</t',sys.stdin.read()),key=lambda t:int(t[0])))
```
Takes the HTML source on stdin, produces code on stdout.
[Answer]
# Mathematica, 106 bytes
```
""<>(v=ImportString[#~StringDrop~157,"XML"][[2,3,4;;;;2]])[[;;,3]][[Ordering[FromDigits/@v[[;;,2,2,2]]]]]&
```
Note: The input needs to be in exactly the format specified by the example.
[Answer]
# [V](https://github.com/DJMcMayhem/V), 28 26 25 24 bytes
```
d5jÍx=
ún
JÍ">
lH$dÍî
```
[Try it online!](https://tio.run/##jZTRjtJAFIbveQCvx6MXbrJlOp1paZF2E4GsGqObFTVesnQKdbstaWeh650PsK/iA3gpD4Yz01pSA0gvmiH/Oef7@eekq@02tL9tHn//KP3O5lfaeavOEHSSJ6@fh5vHzc/tdnBR3iVoxfMizlIfSNcExNNZFsbp3Id7ERkuXASDp6MPw8nXqzEqVnN09enVuzdDBAbGX@gQ49FkhD5@vkSWaRLTMxnG4/fQQfUDCyGWfYzX63V3TbtZPseTa6xq8fV4aMhGo2mUk7AkELMbilAaVf0DhZQm08LfM0q2mqoFqpJ@mcTp7b5C4nke1qou7RfL6Yz7sMx5wfMV3/nVzzoOxcIHOR3QgsfzhfCBmVVRgAY5nwlU@iDVB/0@UI@aqYV4SCSuEHl2y/sozVL@EkVxktRnQEFTO8BqvsQIXoq/nVXtMxZ61KGyXNJtTacMUJSlwiji71xZACTyaVpEWX7ngz4mU8Ff2OeIsjOUZ0L9MkjvDO1EQ6qGlCFwB1hhg84@@g13b2hNJ1bFt7w2nxzgy/pzZHmNg38MaNmQOgTRMQuh7ZAoqiywOgH7tASYisDeRWC1DDAdgS357Bifhrxns4rv1nxyWgKu4pMd32vxXc0n/7sCm4fspv7/9Q1Q2uZbB/gqYUp3F@C0@Dp/KUNwf4zvemzKeb0CZr0CbtuAfWgFTLUCbuOgHYBWDSlDQI454GzGaK9y4NQJWKdtgKMSsA6toKMTsCS/bPjq2xL8AQ "V – Try It Online")
Explanation:
```
d5j              delete first 6 lines
   Í*<0x81>*x=     In every line, replace everything up to x=" (inclusive) by nothing
ún               Sort numerically
J                Join line (closing </svg>) with next line
 Í*<0x81>*">       In every line, replace everything up to "> by nothing
l␖H$d            Visual block around closing </text> tags, delete
     Íî          In every line, replace \n by nothing.
```
HexDump:
```
00000000: 6435 6acd 8178 3d0a fa6e 0a4a cd81 223e  d5j..x=..n.J..">
00000010: 0a6c 1648 2464 cdee                      .l.H$d..
```
[Answer]
# [QuadS](https://github.com/abrudz/QuadRS), 49 bytes
```
∊c[⍋⊃x c←↓⍎¨@1⍉(⊢⍴⍨2,⍨.5×≢)3↓⍵]
x="(\d+)
>(.)<
\1
```
[Try it online!](https://tio.run/##jZRBbtNAFIb3OcUwbBIRZzyecWoH20UkEUJCUJUCQpRFEo8Tq6md2tMmZYtU0aAgJBbsu@oB4AJwE18kzIxNIqMk1AvL1vvf@37/8@Sz856fLpfZp/ngXbb4nM0/zsAgu/qaXX3LFl9@3T7C2eK6ms1vssWPbHFr1MWtYf7@nl3f1IgS/Xxfmbmweuw/qFW8aqPmVI7xcunsz07H4IIlaRhHLsQNHQIWDWI/jIYuPOeBZsF9z7nXedE@envQBenFEBy8evzsaRtADaE3pI1Q56gDXr5@Agxdx7qtU4S6z2EFFBcccT5pITSdThtT0oiTITo6RFKLDrttTTRqq0YxCQkC1hs@96GnZjgSKUxGqbthlGjVZQvMJa3ZOIxONgmxbdtIVZW0lU56A@bCScJSllywtV91TUOfj1wopkMwYuFwxF1I9VzkASdhAw5EmqJ6qe5b9GA1NeWXY4FLeRKfsBaI4og9BEE4HhfPEHgrrYPkfIHhbMb/duba@9S3SZMIuaCbik4oBEEccS0NPzBpAQKe9KI0iJNTF6rHcY@zqlkHhNZAEnP5puG9GlgXNVHVRBl6loMk1qtsoveZ1ScFHRs537DLfLyFL/R1YNgrB/8YUGVN1KEX7LLgm00cBLkFWiRg3i0BKiMw1xEYJQNURWAKPt3FJz7bM2nOtwo@vlsCluTjNd8u8S3Fx/87ApP5tF98f3EChJT5xha@TJiQ9QE0S3yVvyhD73wX37Jpj7FiBfRiBayyAXPbCuhyBayVg3IAqqqJMvTwLgeMDijZyx00iwSMu21AUyZgbFvBpkrAEPzZii//Ld7yDw "QuadS – Try It Online")
Finds x values (digit-runs after `x="`) and "letters" (pinned by closing and opening tags), then executes the following APL (where `⍵` is the list of found x values and letters, in order of appearance):
`3↓⍵` drop the first three elements (spaces around `<rect`…`/rect>` and the `<rect`'s x value).
`(`…`)` apply the following tacit function on that:
 `≢` the number of remaining items
 `.5×` halve that
 `2,⍨` append a two
 `⊢⍴⍨` reshape to that shape (i.e. an n×2 matrix)
`⍉` transpose (to a 2×n matrix)
`⍎¨@1` execute each string in the first row (turning them into numbers)
`↓` split the matrix into two vectors (one per row)
`x c←` store those two in x (x values) and c (characters) respectively
`⊃` pick the first (x)
`⍋` grade up (the indices into x which would sort x)
`c[`…`]` use that to index into `c`
`∊` **ϵ**nlist (flatten) because each letter is a string by itself
---
The equivalent APL expression of the entire QuadS program is:
```
∊c[⍋⊃x c←↓⍎¨@1⍉(⊢⍴⍨2,⍨.5×≢)3↓'x="(\d+)"' '>(.)<'⎕S'\1'⊢⎕]
```
[Answer]
# Java 8, ~~197~~ 173 bytes
```
import java.util*;s->{String a[]=s.split("x=\""),r="";Map m=new TreeMap();for(int i=2;i<a.length;m.put(new Long(a[i].split("\"")[0]),a[i++].split(">|<")[1]));return m.values();}
```
Outputs a `java.util.Collection` of characters.
**Explanation:**
[Try it online.](https://tio.run/##lZXbbtNAEIbv@xSDubFp7fUxtZsDEmmFkKBUtIBQkwvHXifbOmvLu05SoM9eZt3EJRGFEEWJd/45fDszSm7iRWwWJeU36e0Dm5dFJeEGbVYtWW696gK@CIGLGO1FBnJGYXInqZkUNZcHSR4LAR9ixn8cADAuaZXFCYVzdQQYFnlOE8kKDol@KSvGpyCMLmr3B/ghZCxZAufAoQ8Pwhz8WPvE1@O@sESZM6lrq/5I04zuh7iEeZ/TJVxVlOJJN7pZUelYFFjf7bJebOWUT@WsO7fKWurK9X3Bp3p8zcabZCrVtT02jtB4eNiaBz97aHfGhtGtqKwrDnNrEec1FVjl/kER47usJznyrrEXBUthjldf3@x6HBuP1768E5LOraKWVomKzLnOrURvNACt93o1z2FBK4GNwcs5lj3SgPKkSDENGmqZmeFIez3ovTj9OLz6dnEGYjGFi89v3r8bwkgzCfnqDQk5vTqFyy9vwbVtx45sn5Czc8w00mZSlieELJdLa@lZRTUlV5@I8iKfzoYmhphtCOYgmNyxrVSmI22gHbaYqiaSctH/U0bMYKtILNg4naxyxm//6OpEUUQa@dH5RJS4JOhaVlTQakHRvGSpnKEJ0@JpRtl0JvHo278zKaoKFwrUTii/u/X3X6JxXHe5KiZkVdzSE@AFp13IWJ6vn9Fn0CMq73YlSVeyjX70f@mnkdfxVIhCCNYIno8PWcGlKdh32nCgQVYxF7iiczQ0z3ksqR4cgecbUBVSnUzn2IAn0UTVRBkvHfaIAvg30oSGE69FctwNlBvtQjnPQmHUEbhRi7VD1cgm6siV7cuVBh0nyzZcfturYP9e@apZwVOz3C0qv2lWoKD8faG8lB4H/gYqbKGc/XsVKijnCSraggobKOe/JhjQ1J@0nWoH6Hm7UO6zUGpAnvc0v84WVDM@lBGq3hcqjPyY0nat7Hatwl2q4Pm1stVahS3Wdqsa1UQZsZx9saif@N7xBqvT9srdf6s6qlfuc7veaXrlKqjVLpTWU794A81Y/4fdP/wC)
```
import java.util*;            // Required import for Map and TreeMap
s->{                          // Method with String as both parameter and return-type
  String a[]=s.split("x=\""), //  Split the input by `x="`, and store it as String-array
         r="";                //  Result-String, starting empty
  Map m=new TreeMap();        //  Create a sorted key-value map
  for(int i=2;                //  Skip the first two items in the array,
      i<a.length;             //  and loop over the rest
    m.put(new Long(a[i].split("\"")[0]),
                              //   Split by `"` and use the first item as number-key
          a[i++].split(">|<")[1]));
                              //   Split by `>` AND `<`, and use the second item as value
    return m.values();}       //  Return the values of the sorted map as result
```
[Answer]
# [Gema](http://gema.sourceforge.net/), 65 characters
```
x\="<D>*\>?=@set{$1;?}
?=
\Z=${5}${25}${45}${65}${85}${105}${125}
```
In Gema there is no sorting, but fortunately is not even needed.
Sample run:
```
bash-4.4$ gema 'x\="<D>*\>?=@set{$1;?};?=;\Z=${5}${25}${45}${65}${85}${105}${125}' < captcha.svg
8u4x81f
```
[Answer]
# [XMLStarlet](http://xmlstar.sourceforge.net/), 46 characters
```
xmlstarlet sel -t -m //_:text -s A:N:U @x -v .
```
Hopefully this is valid solution as XMLStarlet is transpiler that generates and executes XSLT code, which is a Turing complete language.
Sample run:
```
bash-4.4$ xmlstarlet sel -t -m //_:text -s A:N:U @x -v . < captcha.svg 
8u4x81f
```
[Answer]
## PHP, 96 bytes
*Given that `$i` is the input string*
```
preg_match_all('|x="(\d+).*(.)\<|',$i,$m);$a=array_combine($m[1],$m[2]);ksort($a);echo join($a);
```
[Answer]
# [Clean](https://clean.cs.ru.nl), ~~277~~ 150 bytes
Yay pattern matching!
```
import StdEnv,StdLib
?s=map snd(sort(zip(map(toInt o toString)[takeWhile isDigit h\\['" x="':h]<-tails s],[c\\[c:t]<-tails s|take 7 t==['</text>']])))
```
[Try it online!](https://tio.run/##jZRdb9owFIbv@RVn7gUgEZxPSCgJ0gBVlaqtKt2qiXIREgesBgfFLtBqv33MTtIipsJ6k8R@X5/nfESOUhKy/SqLn1MCq5CyPV2ts1zARMRjtmnJ1w2d1wbcX4Vr4CxucKk2Xum6ITcaIrtmAjIQ2UTklC2aUxE@kYclldEoH9EFFbB8fJzWEex8VO8tZ31NhDTlwGetaSSVqCcOe7/VaeiC8P1pvY8F2YmgPps1m839RIS5qF0A3yzAB6kOdqsUNiTnNGM@Mto6AsKiLJZZ@OhZJJqLBkH/y@j78P7X7bg4d/vj6831EJCG8YM1xHh0P4LJzyswdd3QPd3GePwNoaUQ6x7G2@22vbXaWb7A93dYWfDdeKhJv/bulwGwDGzo7VjEKOgriEyLcf@DKPKUrtyotPR2KWVPHxkNz/NwoRbWHl@HEfHROiec5BuCtjQWSx/JeAiWhC6Wwke2LvE5iYTqs9x/KZ4nnMDFSyojcpFnT6QHLGPkEhKaptU3gqCPVbQA@moIbwdKy4Ude1bHuixm6hQsy0aQZExonL4SBUQg8pDxJMtXPio@01CQhtMCy25Cngm10oxuEw6iJlVNyihwq9l/BJ8Td25VcMMs8aZ3jDdO4KW/Bab3nsA//ELWpI6C5EwGsdMxkqTMwK7qdz5Xv60a4BwaYB7x7aIBjsTbZ/BWTLqOXeLdCm98rn5X4Y0D3jvCuwXe@E//HRLb86r6qv2WdYw3T@BVey3r0P3OEb5ovpRR8HwG73p2SEg1fr0av3vMd06NX1fjd98TOC6/UDUpo8A4kwCxI9vqlgl0qvrNz02/o@o3T/19naJ@U@J3b3h1XcgLsObDQF1gtf2fKEnDBd9r1zf70QsLVzQqF7cyhsIVi/LS/gs "Clean – Try It Online")
Defines the function `?`, taking `[Char]` and giving `[Char]`.
]