[Question]
  [
# Task
Your task is to take a character in:
`AÁÀÃÂBCÇDEÉÊFGHIÍJKLMNOÕÓÔPQRSTUÚVWXYZaáàãâbcçdeéêfghiíjklmnoõóôpqrstuúvwxyz`
and turn it into a characters in:
`AAAAABCCDEEEFGHIIJKLMNOOOOPQRSTUUVWXYZaaaaabccdeeefghiijklmnoooopqrstuuvwxyz`
by the obvious operation: dropping the accents in the letters.
# Input
A character in any sensible format, including but not limited to:
* A string with only one character;
* A unicode codepoint.
# Output
The transformed char in any sensible format, which includes:
* A string with only one char;
* A unicode codepoint.
# Test cases
```
'A' -> 'A'
'Á' -> 'A'
'À' -> 'A'
'Ã' -> 'A'
'Â' -> 'A'
'B' -> 'B'
'C' -> 'C'
'Ç' -> 'C'
'D' -> 'D'
'E' -> 'E'
'É' -> 'E'
'Ê' -> 'E'
'F' -> 'F'
'G' -> 'G'
'H' -> 'H'
'I' -> 'I'
'Í' -> 'I'
'J' -> 'J'
'K' -> 'K'
'L' -> 'L'
'M' -> 'M'
'N' -> 'N'
'O' -> 'O'
'Õ' -> 'O'
'Ó' -> 'O'
'Ô' -> 'O'
'P' -> 'P'
'Q' -> 'Q'
'R' -> 'R'
'S' -> 'S'
'T' -> 'T'
'U' -> 'U'
'Ú' -> 'U'
'V' -> 'V'
'W' -> 'W'
'X' -> 'X'
'Y' -> 'Y'
'Z' -> 'Z'
'a' -> 'a'
'á' -> 'a'
'à' -> 'a'
'ã' -> 'a'
'â' -> 'a'
'b' -> 'b'
'c' -> 'c'
'ç' -> 'c'
'd' -> 'd'
'e' -> 'e'
'é' -> 'e'
'ê' -> 'e'
'f' -> 'f'
'g' -> 'g'
'h' -> 'h'
'i' -> 'i'
'í' -> 'i'
'j' -> 'j'
'k' -> 'k'
'l' -> 'l'
'm' -> 'm'
'n' -> 'n'
'o' -> 'o'
'õ' -> 'o'
'ó' -> 'o'
'ô' -> 'o'
'p' -> 'p'
'q' -> 'q'
'r' -> 'r'
's' -> 's'
't' -> 't'
'u' -> 'u'
'ú' -> 'u'
'v' -> 'v'
'w' -> 'w'
'x' -> 'x'
'y' -> 'y'
'z' -> 'z'
```
You can check [here](https://tio.run/##XY85T8NAFIR7/4rVNmtLJA0NQgIJCOEO9ykKG3sdLyRrs14DSRSJo0AgUQENFUeBQKICGtr5YcZOkBIx5cw3T2@ihg5COZimoh6FSpNECjf0uOdoxzA87hMZqrpTE01uxtawQTIprhMl@8liD2KVcokNkNja7bB/KnKZsyZzYleILGeimnU4@4d5vIPRRPuFIWqlmseajBA6hjOc4gLn4xO4LE3iCtflqekZ3MzOzS9UFnGPW9wtLa@srq3jYWNza3vHwRMe8YLnPRevHscb3v1qIPCxf1CryxDf@MRXdKhineDn6Pik0aSGESkhtUlt26aW4YeKuIGjiJAk/6M7vov4lLXyrM1IYZSwVm9/7lptlvX7j6W/) for a Python reference implementation without regexes.
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so shortest submission in bytes, wins! If you liked this challenge, consider upvoting it... And happy golfing!
  
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 39 bytes
A port of [my CP-1610 answer](https://codegolf.stackexchange.com/a/200596/58563).
I/O format: a Unicode code point.
```
n=>n>>7?Buffer("ACEIOOU")[n/4&7]^n&32:n
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/P1i7Pzs7c3qk0LS21SEPJ0dnV098/VEkzOk/fRM08Ni5PzdjIKu@/dbSenp6S4@HGww2Hmw83OTkfbndxPdx5uMvN3cPzcK@Xt4@vn//hqYcnH54SEBgUHBJ6eFZYeERkVOLhhYcXHF58eFFS8uHlKamHVx5elZaekXl4bVZ2Tm5e/uGthzcf3lJQWFRcUnp4V1l5RWWVUiyXXlp@kWticoZGsoKtnUJyfl5xfk6qXk5@ukaCukp1cq26gq6unQKQGVxSlJmXrpdWlJ/rDPRQQH5mXolGmkayXjKM51iiYaCpqVmrnqCp@R8A "JavaScript (Node.js) – Try It Online")
---
# [JavaScript (Node.js)](https://nodejs.org), 44 bytes
I/O format: a string with only one character.
```
c=>'oeaUICuic?OEA'[Buffer(c)[1]*13%59%13]||c
```
[Try it online!](https://tio.run/##AeAAH/9qYXZhc2NyaXB0LW5vZGX/Zj3/Yz0@J29lYVVJQ3VpYz9PRUEnW0J1ZmZlcihjKVsxXSoxMyU1OSUxM118fGP/O1suLi4iQcOBw4DDg8OCQkPDh0RFw4nDikZHSEnDjUpLTE1OT8OVw5PDlFBRUlNUVcOaVldYWVphw6HDoMOjw6JiY8OnZGXDqcOqZmdoacOtamtsbW5vw7XDs8O0cHFyc3R1w7p2d3h5eiJdCi5mb3JFYWNoKGMgPT4gY29uc29sZS5sb2coYCcke2N9JyAtLT4gJyR7ZihjKX0nYCkp/w "JavaScript (Node.js) – Try It Online")
### How?
When passed into `Buffer()`, the accented letters used in the challenge are turned into two bytes \$(b\_0,b\_1)\$, corresponding to their UTF-8 encoding. The non-accented letters are turned into a single byte \$b\_0\$ corresponding to their regular ASCII code (or 1-byte UTF-8 encoding).
*Examples:*
```
Buffer('À') // --> <Buffer c3 80>
Buffer('B') // --> <Buffer 42>
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/f8/OT@vOD8nVS8nP13DqTQtLbVIQ/1wg7qmJhc2GSegxP//AA "JavaScript (Node.js) – Try It Online")
We use the following formula to convert the 2nd byte of accented letters to an index \$n\$ into a 13-character lookup string of non-accented letters:
$$n=((b\_1\times13)\bmod 59)\bmod 13$$
This results in `NaN` for non-accented letters, which are simply left unchanged.
```
  c  |   UTF-8    | 2nd byte | * 13 | mod 59 | mod 13 | output
-----+------------+----------+------+--------+--------+--------
 'À' | 0xC3, 0x80 |    128   | 1664 |   12   |   12   |  'A'
 'Á' | 0xC3, 0x81 |    129   | 1677 |   25   |   12   |  'A'
 'Â' | 0xC3, 0x82 |    130   | 1690 |   38   |   12   |  'A'
 'Ã' | 0xC3, 0x83 |    131   | 1703 |   51   |   12   |  'A'
 'Ç' | 0xC3, 0x87 |    135   | 1755 |   44   |    5   |  'C'
 'É' | 0xC3, 0x89 |    137   | 1781 |   11   |   11   |  'E'
 'Ê' | 0xC3, 0x8A |    138   | 1794 |   24   |   11   |  'E'
 'Í' | 0xC3, 0x8D |    141   | 1833 |    4   |    4   |  'I'
 'Ó' | 0xC3, 0x93 |    147   | 1911 |   23   |   10   |  'O'
 'Ô' | 0xC3, 0x94 |    148   | 1924 |   36   |   10   |  'O'
 'Õ' | 0xC3, 0x95 |    149   | 1937 |   49   |   10   |  'O'
 'Ú' | 0xC3, 0x9A |    154   | 2002 |   55   |    3   |  'U'
 'à' | 0xC3, 0xA0 |    160   | 2080 |   15   |    2   |  'a'
 'á' | 0xC3, 0xA1 |    161   | 2093 |   28   |    2   |  'a'
 'â' | 0xC3, 0xA2 |    162   | 2106 |   41   |    2   |  'a'
 'ã' | 0xC3, 0xA3 |    163   | 2119 |   54   |    2   |  'a'
 'ç' | 0xC3, 0xA7 |    167   | 2171 |   47   |    8   |  'c'
 'é' | 0xC3, 0xA9 |    169   | 2197 |   14   |    1   |  'e'
 'ê' | 0xC3, 0xAA |    170   | 2210 |   27   |    1   |  'e'
 'í' | 0xC3, 0xAD |    173   | 2249 |    7   |    7   |  'i'
 'ó' | 0xC3, 0xB3 |    179   | 2327 |   26   |    0   |  'o'
 'ô' | 0xC3, 0xB4 |    180   | 2340 |   39   |    0   |  'o'
 'õ' | 0xC3, 0xB5 |    181   | 2353 |   52   |    0   |  'o'
 'ú' | 0xC3, 0xBA |    186   | 2418 |   58   |    6   |  'u'
```
[Answer]
# [PHP](https://php.net/), 42 39 34 bytes
```
<?=iconv('','us//TRANSLIT',$argn);
```
-3 Bytes thanks to @Neil
[Try it online!](https://tio.run/##AZgAZ/9waHD//zw/PWljb252KCcnLCd1cy8vVFJBTlNMSVQnLCRhcmduKTv//0HDgcOAw4PDgkJDw4dERcOJw4pGR0hJw41KS0xNTk/DlcOTw5RQUVJTVFXDmlZXWFlaYcOhw6DDo8OiYmPDp2Rlw6nDqmZnaGnDrWprbG1ub8O1w7PDtHBxcnN0dcO6dnd4eXr@b3B0aW9uc/8tRg "PHP – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 22 bytes
```
s=>s.normalize`NFD`[0]
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@7/Y1q5YLy@/KDcxJ7MqNcHPzSUh2iD2f0lqcUlyYnGqgq1CtJ6enpLj4cbDDYebDzc5OR9ud3E93Hm4y83dw/Nwr5e3j6@f/@GphycfnhIQGBQcEnp4Vlh4RGRU4uGFhxccXnx4UVLy4eUpqYdXHl6Vlp6ReXhtVnZObl7@4a2HNx/eUlBYVFxSenhXWXlFZZVSLBfMWr20/CLXxOQMjWQFWzuFaoXk/Lzi/JxUvZz8dI1kHQV1XTt1HYU0jWRNTYVaTev/AA "JavaScript (Node.js) – Try It Online")
save 2 bytes, thanks Arnauld.
[Answer]
# T-SQL, ~~35~~ 33 bytes
```
SELECT v COLLATE Greek_BIN FROM t
```
Input is taken from a pre-existing table *t* with `CHAR(1)` column *v*, [per our IO standards](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341).
This code simply displays the input after converting it to a different *SQL collation*.
[SQL collations](https://docs.microsoft.com/en-us/sql/relational-databases/collations/collation-and-unicode-support?view=sql-server-ver15) define sorting rules as well as case and accent sensitivity properties for SQL text data. They can even define the valid code page, which is how this particular trick works. [Code page 1253](https://en.wikipedia.org/wiki/Windows-1253) ("Greek - ANSI") doesn't include any of the accented characters in the question, so the collation conversion maps each to its non-accented version.
I based my version on [this StackOverflow answer](https://stackoverflow.com/a/56791799/21398), which uses a more standard collation with a much longer name: `SQL_Latin1_General_CP1253_CI_AI`.
**EDIT**: Saved 2 bytes by replacing `Greek_CS_AI` with `Greek_BIN`. Both use code page 1253, which is really the part that matters, not the "accent insensitive" property.
SQL supports nearly 4000 collations, run this on your SQL server to return all collations that use code page 1253, ordered by the shortest name:
```
SELECT name, bytes=len(name), description, codepage=COLLATIONPROPERTY(name, 'CodePage')
FROM fn_helpcollations()
WHERE COLLATIONPROPERTY(name, 'CodePage') = 1253
ORDER BY len(name)
```
It is possible to replace characters individually, but that is much longer (**79 Bytes**):
```
SELECT TRANSLATE(v,'ÁÀÃÂÇÉÊÍÕÓÔÚáàãâçéêíõóôú','AAAACEEIOOOUaaaaceeiooou')FROM t
```
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~24~~ ~~23~~ 22 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
žy›i•M¦>á•₂вI28&èI96&+
```
-2 bytes thanks to *@Grimmy*.
I/O as unicode codepoint.
[Try it online.](https://tio.run/##AZ8AYP8wNWFiMWX/PXZ5w4fCqUT/xb554oC6aeKAok3Cpj7DoeKAouKCgtCywq4yOCbDqMKuOTYmK/99w6c//0HDgcOAw4PDgkJDw4dERcOJw4pGR0hJw41KS0xNTk/DlcOTw5RQUVJTVFXDmlZXWFlaYcOhw6DDo8OiYmPDp2Rlw6nDqmZnaGnDrWprbG1ub8O1w7PDtHBxcnN0dcO6dnd4eXo)
**Explanation:**
```
žy›i             # If the (implicit) input-codepoint is larger than 128:
    •M¦>á•       #  Push compressed integer 3755486693
          ₂в     #  Convert it to base-26 as list: [1,5,15,21,3,9,15]
    I28&         #  Push the input-codepoint, and bitwise-AND it with 28
        è        #  Index it into the list (0-based and with wraparound)
         I96&    #  Push the input-codepoint, and bitwise-AND it with 96
             +   #  And add it to the indexed value
                 #  (after which it is output implicitly as result)
                 # (implicit else:)
                 #  (take the implicit input-codepoint as implicit output)
```
[See this 05AB1E tip of mine (sections *How to compress large integers?* and *How to compress integer lists?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `•M¦>á•` is `3755486693` and `•M¦>á•₂в` is `[1,5,15,21,3,9,15]`.
[Answer]
# iconv, ~~21~~ 20 bytes
```
iconv -tus//TRANSLIT
```
[Try it online!](https://tio.run/##Tcy3TgNBFIXhnqdY0YxdGIsXQHLOeR3lxvY6Z6@zKAgFAokKaKgIBQKJCmhoebDljE4x031XOvdvNuye43L6relkbXiWK9vrNfO@dCEZMx23cWrYbcs49Iq666juFobnxBD1Y@G1Dh3h4@kTB@LvXPOZ5kvNF8p@0g8GyIBcXCkHySAYIkNyca35RjlMhsEIGQGjZBSMkTH5d6scJ@NggkyASTIJpsgUmCbTYIbMyNqD5jvN98pZMgvmyByYJ/NggSyAJmmCRbIoa4/KJbIElskyWCErYJWsgjWyBjbIhqw9a37S/Kr5RblJNsEW2ZKLN2WLtMA22ZaLd80fyh2yA3bJLtgje2Cf7Mu/T@UBOQCH5BAckSNwTI7BCTkBp@RU1n40f2n@Vp6RM3BOzsEFuQBt0gaX5BJckStZ@1Vek2twQ27ALbkFd@QO3JN78Q8 "Bash – Try It Online") Link includes test suite. Edit: Thanks to @NahuelFouilleul for a 1 byte saving. Port of @Oxgeba's PHP answer, but I used `us` as a synonym for `ASCII` to save a further 3 bytes.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~61~~ 56 bytes
```
lambda s:s[s>'z':]or'EIOOUaaceioou_AAC'[ord(s)*17%67%17]
```
[Try it online!](https://tio.run/##K6gsycjPM/6fpmCrEPM/JzE3KSVRodiqOLrYTr1K3So2v0jd1dPfPzQxMTk1Mz@/NN7R0Vk9Or8oRaNYU8vQXNXMXNXQPPZ/SWpxCdAEJcfDjYcbDjcfbnJyPtzu4nq483CXm7uH5@FeL28fXz//w1MPTz48JSAwKDgk9PCssPCIyKjEwwsPLzi8@PCipOTDy1NSD688vCotPSPz8Nqs7JzcvPzDWw9vPryloLCouKT08K6y8orKKiUurrT8IoXkjMQihcw8BZDVVlwKQFBQlJlXopGmpF4NkqtVV9C1U1CvTtMA8TRr1ZU0/wMA "Python 3 – Try It Online")
---
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), ~~76~~ 74 bytes
```
lambda s:(n:=name(s)*2)[21::-2].title()['SM'in n]
from unicodedata import*
```
[Try it online!](https://tio.run/##FY65TsNAAAV7f8XKje1IQcI0yJKRuM9AINwhxcb24gV716w3QIgicRQIJCqgoeIoEEhUQEP7PszErxtNMS/r6liKkdFMFczfKxKatkNKcs8Wni9oGtm5U3GdpjvseVW3NaS5TiLbaVqNmsUFES2DKZmSjuCBDKOQakp4mkmlK4WOck18Yo7jAue4wuXEJK6npnGD25nZuXncLSwu1ZZX8Ih7PNRX1xrrG3ja3Nre2aV4wTPe8NoO8B5G@MAn2485vg4Ok1RI/OIbP9mRynUHf8cnp90z0zCYVCSIqSKDW2XaM8hgmeJC28y0eqXrW6Q6Rqwes0ty@pbpFP8 "Python 3.8 (pre-release) – Try It Online")
**Examples**
```
s                               'À'
name(s)                         'LATIN CAPITAL LETTER A WITH GRAVE'
name(s)*2                       'LATIN CAPITAL LETTER A WITH GRAVELATIN CAPITAL LETTER A WITH GRAVE'
                                  ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
(name(s)*2)[21::-2]             'ARTE AIA IA'
(name(s)*2)[21::-2].title()     'Arte Aia Ia'
'SM' in name(s)*2 ==            False == 0
(name(s)*2)[21::-2].title()[0]  'A'
s                               'À'
name(s)                         'LATIN SMALL LETTER C WITH CEDILLA'
name(s)*2                       'LATIN SMALL LETTER C WITH CEDILLALATIN SMALL LETTER C WITH CEDILLA'
                                  ^ ^ ^ ^ ^ ^ ^ ^ ^ ^ ^
(name(s)*2)[21::-2]             'WCRTE LM IA'
(name(s)*2)[21::-2].title()     'Wcrte Lm Ia'
'SM' in name(s)*2               True == 1
(name(s)*2)[21::-2].title()[1]  'c'
```
---
# [Python 3](https://docs.python.org/3/), 55 bytes
Basically the same as tsh's [JavaScript answer](https://codegolf.stackexchange.com/a/200587/64121).
```
lambda s:normalize('NFD',s)[0]
from unicodedata import*
```
[Try it online!](https://tio.run/##TU85SwNBGO33V3xsM1lREOwCEdQY76jxviCTPdzR3Zl1dqImIeBRiIKV2lh5FKJgpTa274etWSz0le/ivaRlQiWHsqC0nUU8bnic0qJUOuaRaPsFVq2UWX/qbA3uWIFWMTWlcJXne9xwEnGitOnLjJ8aKpE9glOc4Bxno2O4KI/jEleVickpXE/PzM5V53GHG9wuLNaWlldwv7q2vrHJ8YgHPOOp4eLF8/GKt2A3FHjf249iqfCFD3wmBzo1TXwfHh232rZlJVpIU7Dr9brtWIHS5IZck5CU7yha1MOvJbBZJ9e6jAaGiXX@buWs02W9/P@y7Ac "Python 3 – Try It Online")
[Answer]
# [CP-1610](https://en.wikipedia.org/wiki/General_Instrument_CP1600) machine code, ~~27 26 22~~ 21 DECLEs1 ≈ 27 bytes
*As per the exception described [in this meta answer](https://codegolf.meta.stackexchange.com/a/10810/58563), the exact score is **26.25 bytes** (210 bits)*
A routine taking a Unicode code point in **R0** and returning another code point in the same register.
```
**081**  |         MOVR    R0,     R1
**045**  |         SWAP    R1,     2
**203 009**  |         BPL     @@rtn
**065**  |         SLR     R1,     2
**3B9 007**  |         ANDI    #7,     R1
**0F9**  |         ADDR    R7,     R1
**2F9 006**  |         ADDI    #6,     R1
**3B8 020**  |         ANDI    #32,    R0
**3C8**  |         XOR@    R1,     R0
**0AF**  | @@rtn   JR      R5
**041 043 045 049** |         STRING  "ACEIOOU"
**04F 04F 055**  |
```
### How?
All the special characters we're interested in are located in the `0xC0-0xFF` Unicode range.
```
full range        relevant letters  replacement
   | 0123 4567       | 0123 4567       | 0123 4567
---+----------    ---+----------    ---+----------
C0 | ÀÁÂÃ ÄÅÆÇ    C0 | ÀÁÂÃ ---Ç    C0 | AAAA ---C
C8 | ÈÉÊË ÌÍÎÏ    C8 | -ÉÊ- -Í--    C8 | -EE- -I--
D0 | ÐÑÒÓ ÔÕÖ×    D0 | ---Ó ÔÕ--    D0 | ---O OO--
D8 | ØÙÚÛ ÜÝÞß    D8 | --Ú- ----    D8 | --U- ----
E0 | àáâã äåæç    E0 | àáâã ---ç    E0 | aaaa ---c
E8 | èéêë ìíîï    E8 | -éê- -í--    E8 | -ee- -i--
F0 | ðñòó ôõö÷    F0 | ---ó ôõ--    F0 | ---o oo--
F8 | øùúû üýþÿ    F8 | --ú- ----    F8 | --u- ----
```
As shown in the tables above, each group of \$4\$ accented letters is mapped to a single non-accented letter. So, given a code point \$n\$, we compute the index:
$$i=\left\lfloor\frac{n}{4}\right\rfloor\bmod 8$$
We pick the corresponding letter from the lookup string `"ACEIOOU"` and then apply the correct case.
### Full commented test code
```
        ROMW    10                ; use 10-bit ROM width
        ORG     $4800             ; map this program at $4800
        ;; ------------------------------------------------------------- ;;
        ;;  main code                                                    ;;
        ;; ------------------------------------------------------------- ;;
main    PROC
        SDBD                      ; set up an interrupt service routine
        MVII    #isr,   R0        ; to do some minimal STIC initialization
        MVO     R0,     $100
        SWAP    R0
        MVO     R0,     $101
        EIS                       ; enable interrupts
        SDBD                      ; R4 = pointer into the test case table
        MVII    #tc,    R4
        MVII    #$200,  R3        ; R3 = backtab pointer
        MVII    #76,    R2        ; R2 = number of test cases
@@loop  MVI@    R4,     R0        ; R0 = character code point
        CALL    conv              ; invoke our routine
        SUBI    #32,    R0        ; turn the result into an Intellivision card
        SLL     R0,     2
        SLL     R0
        MVO@    R0,     R3        ; draw it
        INCR    R3                ; increment the backtab pointer
        DECR    R2                ; next test case
        BNEQ    @@loop
        DECR    R7                ; done: loop forever
        ENDP
        ;; ------------------------------------------------------------- ;;
        ;;  test cases                                                   ;;
        ;; ------------------------------------------------------------- ;;
tc      PROC
        DECLE   65   ; A
        DECLE   193  ; Á
        DECLE   192  ; À
        DECLE   195  ; Ã
        DECLE   194  ; Â
        DECLE   66   ; B
        DECLE   67   ; C
        DECLE   199  ; Ç
        DECLE   68   ; D
        DECLE   69   ; E
        DECLE   201  ; É
        DECLE   202  ; Ê
        DECLE   70   ; F
        DECLE   71   ; G
        DECLE   72   ; H
        DECLE   73   ; I
        DECLE   205  ; Í
        DECLE   74   ; J
        DECLE   75   ; K
        DECLE   76   ; L
        DECLE   77   ; M
        DECLE   78   ; N
        DECLE   79   ; O
        DECLE   213  ; Õ
        DECLE   211  ; Ó
        DECLE   212  ; Ô
        DECLE   80   ; P
        DECLE   81   ; Q
        DECLE   82   ; R
        DECLE   83   ; S
        DECLE   84   ; T
        DECLE   85   ; U
        DECLE   218  ; Ú
        DECLE   86   ; V
        DECLE   87   ; W
        DECLE   88   ; X
        DECLE   89   ; Y
        DECLE   90   ; Z
        DECLE   97   ; a
        DECLE   225  ; á
        DECLE   224  ; à
        DECLE   227  ; ã
        DECLE   226  ; â
        DECLE   98   ; b
        DECLE   99   ; c
        DECLE   231  ; ç
        DECLE   100  ; d
        DECLE   101  ; e
        DECLE   233  ; é
        DECLE   234  ; ê
        DECLE   102  ; f
        DECLE   103  ; g
        DECLE   104  ; h
        DECLE   105  ; i
        DECLE   237  ; í
        DECLE   106  ; j
        DECLE   107  ; k
        DECLE   108  ; l
        DECLE   109  ; m
        DECLE   110  ; n
        DECLE   111  ; o
        DECLE   245  ; õ
        DECLE   243  ; ó
        DECLE   244  ; ô
        DECLE   112  ; p
        DECLE   113  ; q
        DECLE   114  ; r
        DECLE   115  ; s
        DECLE   116  ; t
        DECLE   117  ; u
        DECLE   250  ; ú
        DECLE   118  ; v
        DECLE   119  ; w
        DECLE   120  ; x
        DECLE   121  ; y
        DECLE   122  ; z
        ENDP
        ;; ------------------------------------------------------------- ;;
        ;;  ISR                                                          ;;
        ;; ------------------------------------------------------------- ;;
isr     PROC
        MVO     R0,     $0020     ; enable display
        CLRR    R0
        MVO     R0,     $0030     ; no horizontal delay
        MVO     R0,     $0031     ; no vertical delay
        MVO     R0,     $0032     ; no border extension
        MVII    #$D,    R0
        MVO     R0,     $0028     ; light-blue background
        MVO     R0,     $002C     ; light-blue border
        JR      R5                ; return from ISR
        ENDP
        ;; ------------------------------------------------------------- ;;
        ;;  our routine                                                  ;;
        ;; ------------------------------------------------------------- ;;
conv    PROC
        MOVR    R0,     R1        ; copy R0 to R1
        SWAP    R1,     2         ; copy the lower byte of R1 to its upper byte,
                                  ; resulting in a negative word for an accented letter
        BPL     @@rtn             ; return right away if it's a regular ASCII character
        SLR     R1,     2         ; right-shift by 2 positions
        ANDI    #7,     R1        ; isolate the 3 least significant bits
        ADDR    R7,     R1        ; add the address of our lookup string,
        ADDI    #6,     R1        ; computed as PC + 6
        ANDI    #32,    R0        ; isolate the case bit of the original character
        XOR@    R1,     R0        ; XOR it with the non-accented letter
@@rtn   JR      R5                ; return
        STRING  "ACEIOOU"         ; lookup string
        ENDP
```
### Output
[![output](https://i.stack.imgur.com/CGv7c.gif)](https://i.stack.imgur.com/CGv7c.gif)
*screenshot from [jzIntv](http://spatula-city.org/~im14u2c/intv/)*
---
*1. A CP-1610 opcode is encoded with a 10-bit value (0x000 to 0x3FF), known as a 'DECLE'.*
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 37 bytes
A port of [my CP-1610 answer](https://codegolf.stackexchange.com/a/200596/58563).
I/O format: a Unicode code point.
```
f(n){n=n>>7?"ACEIOOU"[n/4&7]^n&32:n;}
```
[Try it online!](https://tio.run/##bdRLTxNhFMbxPZ9i0kTSJpB2ppdpJWIQURGx3vAaTero1CK8IiAohAR1YTRxpW5ceVkYTVypG7d8L8cNz7OZ//qXc@Y95zmZbHKYZUWRV0NtNxwL09Pp8crM7Nx8v79UuRXqrfH09p0w3kyOhqm9YnUwCtXa7lgUra2PwmZerRzJKhNRXu20o1ptKqrXo5kyxr3mIR48J02k@6Rt6UvSlvQFPKqjR50ATIWz1Lenvq@gtKvSk4A94VwZk0asvq9JvYk3ZU0banwKMBaeBkyEZwCbwnl6kbf/FkpbKj0L6ItYAHQy5wCdzCKgd38e0Lvvwyyxr/ADqZN5R@pk3pe162QuADqZi4BO5hKgk7kM6N1fAfTul2iWrmb5CKVO5iqgk7kG6GSuAzqZG2XseX83Af3NAcyS@D4/k/rv8Ik0lX4l7Ui/wKM8611Az5pB36bv7Bv8dxqNQ71HqNL71NfX/Z3Um/hBjXXdOaEaDwnV9wGhwhnRi7z9n1Sq7S8TqvQhoa57hVC/9VXAWLsPhNr9I5il5Sv8Q@pkfpE6md/0WSWzRqjGjwnVd51QD94g1O43CbX7JzBLWxs8@EulSmaLUMlsAybq@5RQyTwj1P52xvaKf1m@MhhuFJPb/wE "C (gcc) – Try It Online")
---
# [C (gcc)](https://gcc.gnu.org/), 45 bytes
I/O format: a Unicode code point.
```
f(n){n=n>>7?"ooieca?UOOIECAu"[n*15%61%15]:n;}
```
[Try it online!](https://tio.run/##bdRLTxNxFMbhPZ9i0qRJayR0pp1eIEIQUfFCFcQLxEUdmVqFKXIRhZB4WRhNXKEbV14WRhNX4sYt34txw/tu5rd@cs78z3lPJhntJ0mep5Wsup@dyyYnW1Ol4XCwmvSmlrrdudmZ6Z3SSnYmjMvNsBzG98eziYN8vTfIKtX9kSDY2Bxk22mlVE5KZ4O00oyDanUiGBsLposYduqnePyKNJK@JI2lb0gb0tfwqKYedR6wJZyhvh31fQulbZVeAOwIZ4sY1UL1fUfqTbwvaqumxhcBQ@ElwEh4GbAunKMXefsfoLSh0iuAvoirgE7mGqCTuQ7o3c8DevddmCX0FX4idTKHpE7mY1HbTuYGoJO5CehkFgCdzCKgd38L0LtfolnamuUzlDqZ24BO5g6gk7kL6GTuFbHj/S0D@ps9mCXyfX4l9d/hC2lL@p20Kf0Gj/KsDwA9awJ9676zH/DfqdVO9SGhSlepr6/7J6k38Ysa67pTQjXuE6rvI0KFM6AXefu/qVTbf0yo0ieEuu41Qv3W1wFD7T4j1O6HMEvDV/iX1Mn8IXUyR/RZJbNBqMZPCdV3k1AP3iLU7rcJtfsdmCXWBo//UamSeUaoZHYBI/V9TqhkXhBqf3sjB/lJkq71@lv56O5/ "C (gcc) – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org/), 41 bytes
```
->c{c<?~?c:"ACEIOOUxaceioou"[c.ord/4%16]}
```
[Try it online!](https://tio.run/##AbIATf9ydWJ5/2Y9/y0@Y3tjPD9@P2M6IkFDRUlPT1V4YWNlaW9vdSJbYy5vcmQvNCUxNl19/yJBw4HDgMODw4JCQ8OHREXDicOKRkdIScONSktMTU5Pw5XDk8OUUFFSU1RVw5pWV1hZWmHDocOgw6PDomJjw6dkZcOpw6pmZ2hpw61qa2xtbm/DtcOzw7RwcXJzdHXDunZ3eHl6Ii5jaGFycy5tYXB7fHh8cCBbeCxmW3hdXX3/ "Ruby – Try It Online")
[Answer]
# PHP 5.4+, 32 bytes
This uses the [`htmlentities()`](https://www.php.net/manual/en/function.htmlentities.php) function to return the HTML entity for the character.
```
<?=htmlentities($argn.$argn)[1];
```
For the `"AÁÀÃÂ"` (Ä is missing from the list), it returns `"A&Aacute;&Agrave;&Atilde;&Acirc;"`.  
Do you see a problem? The character I want is on position 0 or 1.  
So, I just duplicate the input. Problem solved!
You can try this on <http://sandbox.onlinephpfunctions.com/code/690dbfcff4c6dec4170954333c62b9b472eaaa93>
[Answer]
# Java 8, ~~85~~ ~~70~~ ~~47~~ 39 bytes
```
c->c>122?"ACEIOOU".charAt(c/4&7)^c&32:c
```
-46 bytes by creating a port of [*@Arnauld*'s C answer](https://codegolf.stackexchange.com/a/200597/52210), so make sure to upvote him!
[Try it online.](https://tio.run/##ZVA9TwJBEO35FZsryG3BGdHERCIGERUVUBE/o8myHHBw7J67y5eGxI/CaGKlNlZ@FEYTK7WxnR927nF0NJPMzHvz3rwG6ZBYo9L0qUukRDnisLMIQg5TtqgSaqN80A4HiJq0TgSiWNUF70qU6VHbUw5nCQ0ZRHSRiiiHojxiaA75NJakycl4fN5IpTPZQqFkWMGBlDLpxHR0Bh/T6FR8lvqJgOq1y66mji50uFNBLW3GLCrhsNrhESJjsqGzEICkVjRScAHncAWXC2m4XszADdwuLa9k4W51bT2XL8Aj3MPDxuZWcbsETzu7e/sHBF7gGd7gtUzhvWLDB3xWa3UHvhpNt8U4/MI3/HgnQqo2/HW6vf6pkQhl@1LZLYu3leVpA8plpsThqsrFKKlZaSmeDn4WgvRNjIf7cbI5xGNm6YgxDuMc@P8)
**Original answer (85 bytes):**
```
import java.text.*;c->(char)Normalizer.normalize(c,Normalizer.Form.NFD).getBytes()[0]
```
[Try it online.](https://tio.run/##ZZC7TltBEIZ7P8XI1VnAC5RggcTN3A8J5MJFFOv12l5zzu5hd2xsEBJJiohIVIQmVYAiChJVkibtPJhZY4OQaEb/3P75NA3REoVG5aCr08w6hEbIOao28qEijI7C8PgEoAWsKyh3UBWkbRrMyUR4D@tCm5McgDaoXFVIBXEvBZB14UBGW@i0qYFkWHf2yMNCW6oMtTXFMHWaC8GjQC0hBgNT0JWF6ai3ymLrUpHoY@W4eZKRHHlRLgXJ49I84zWFswHMR2xvbL9b7LlmzXISXAfmLasrkAbUAc/ePohXRH3uAbAPMPkZ@kRn9IU@z87R1/kFOqdvpcWlZbpYWV1bjzfoii7p@5u3m1vv3tOPDx@3d3YFXdNPuqWbsqRfFUW/6a5aq2u6bxwkqbH0j/7Q3@zQeWzS/9ZRu3OcL/bPdjyqlNsm8iwAYGIiz/qtqnXPb5z03GeJxiifZ@yx@3o1MlxGkrH@h0@7Dw)
**Explanation:**
```
c->                         // Method with character as both parameter and return-type
  c>122?                    //  If the character isn't a regular letter:
   "ACEIOOU".charAt(        //   Get the character in String "ACEIOOU" at index:
     c/4&7)                 //    c integer-divided by 4 and then bitwise-ANDed by 7
    ^c&32                   //   And convert it to lowercase if the input was lowercase
  :                         //  Else (it is a regular letter):
   c                        //   Simply return the input as is
import java.text.*;         // Required import for both Normalizer
c->                         // Method with String as parameter and character as return-type
 (char)                     //  Convert the following byte to a character:
   Normalizer.normalize(c,  //   Normalize the input-String,
     Normalizer.Form.NFD)   //   using canonical decomposition
   .getBytes())             //   Convert that to a byte-array (UTF-8 encoding by default)
     [0]                    //   And only leave the first byte
```
[Answer]
# ~~[Perl 6](https://www.theregister.co.uk/2019/10/11/perl_6_raku_larry_wall/)~~ [Raku](https://github.com/nxadm/rakudo-pkg), ~~15~~ 14 bytes
```
*.samemark(~0)
```
[Try it online!](https://tio.run/##AZcAaP9wZXJsNv9teSAmZiA9IP8qLnNhbWVtYXJrKH4wKf87CnNheSB8Z2V0LmNvbWI@Pi4mZv9Bw4HDgMODw4JCQ8OHREXDicOKRkdIScONSktMTU5Pw5XDk8OUUFFSU1RVw5pWV1hZWmHDocOgw6PDomJjw6dkZcOpw6pmZ2hpw61qa2xtbm/DtcOzw7RwcXJzdHXDunZ3eHl6)
Returns the string with the same marks/accents as the number `0`, i.e. remove all marks.
[Answer]
# [Turing Machine Code](http://morphett.info/turing/turing.html), ~~796~~ 286 bytes
```
0 * * r 0
0 Á A r 0
0 À A r 0
0 Ã A r 0
0 Â A r 0
0 Ç C r 0
0 É E r 0
0 Ê E r 0
0 Í I r 0
0 Õ O r 0
0 Ó O r 0
0 Ô O r 0
0 Ú U r 0
0 á a r 0
0 à a r 0
0 ã a r 0
0 â a r 0
0 ç c r 0
0 é e r 0
0 ê e r 0
0 í i r 0
0 õ o r 0
0 ó o r 0
0 ô o r 0
0 ú u r 0
0 _ _ * halt
```
[Try it online!](http://morphett.info/turing/turing.html?f92396d8268dd3e33032ab6844e0c03f)
*Saved an incredible 510 bytes thanks to @ovs! That might be some kind of record here on Code Golf*.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 16 bytes
Mathematics is not the only field Mathematica has built-ins for...
```
RemoveDiacritics
```
[Try it online!](https://tio.run/##AZEAbv9tYXRoZW1hdGljYf9GPVz/UmVtb3ZlRGlhY3JpdGljc/9QcmludEBGWyJBw4HDgMODw4JCQ8OHREXDicOKRkdIScONSktMTU5Pw5XDk8OUUFFSU1RVw5pWV1hZWmHDocOgw6PDomJjw6dkZcOpw6pmZ2hpw61qa2xtbm/DtcOzw7RwcXJzdHXDunZ3eHl6Il3/ "Wolfram Language (Mathematica) – Try It Online") (all the characters are in a single string in the link, but it obviously works character-by-character)
# [Sledgehammer](https://github.com/tkwa/Sledgehammer), 4 bytes
```
⣕⠬⣠⢹
```
Corresponds to the code `RemoveDiacritics@Input[]`.
[Answer]
# [R](https://www.r-project.org/), ~~34~~ 32 bytes
-2 thanks to Giuseppe
```
iconv(scan(,''),,"us//TRANSLIT")
```
[Try it online!](https://tio.run/##AYkAdv9y//9pY29udihzY2FuKCwnJyksLCJ1cy8vVFJBTlNMSVQiKf9Bw4HDgMODw4JCQ8OHREXDicOKRkdIScONSktMTU5Pw5XDk8OUUFFSU1RVw5pWV1hZWmHDocOgw6PDomJjw6dkZcOpw6pmZ2hpw61qa2xtbm/DtcOzw7RwcXJzdHXDunZ3eHl6/w "R – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 53 bytes
-1 thanks to Kevin Cruijssen
```
"áéíõúÁÉÍÕÚàêióuÀÊIÓUãeiôuÃEIÔUâeiouÂEIOUÇç"žÀ4×„Cc«‡
```
[Try it online!](https://tio.run/##yy9OTMpM/f9f6fDCwysPrz289fCuw42HOw/3Hp56eNbhBYdXZR7eXHq44XCX5@HJoYcXp2Ye3lJ6uNnV8/CU0MOLUjPzSw83uXr6hx5uP7xc6ei@ww0mh6c/apjnnHxo9aOGhf//U24qAA "05AB1E – Try It Online")
## Explanation
```
"áéíõúÁÉÍÕÚàêióuÀÊIÓUãeiôuÃEIÔUâeiouÂEIOUÇç" A huge lookup table of the unicode characters
žÀ        Push "aeiouAEIOU"
  4×      Repeat it 4 times
    „Cc«  Concatenate "Cc" to the string
        ‡ Transliterate input
```
```
[Answer]
# [Python 2](https://docs.python.org/2/), 141 bytes
```
o='';i=input()
for x in'AÁÀÃÂ CÇ EÉÊ IÍ OÕÓÔ UÚ aáàãâ cç eéê ií oõóô uú'.split():
 if i in x:o=x[0]
print(o,i)[o=='']
```
[Try it online!](https://tio.run/##Fc6xT8JQEAbw/f0Vlzq0EGuMxsTUdEDERAdZZDCEQWsrLzHvNdgm1UlhIJAwCQuTykAgYRIX1vvD6nfD98t9N1wufc261hyVe@RXfYrsozZPAeVZ4p/KRmETh67rlhae6VCbNM@8ikpsjwrSxq3xB7/zgPtU5yE1eMRjuuIJNXnGnzylFs/pnr/5ixf8QxEvKeYVr0nzhiz/8S9vKeede/CSPmtcDhTphDROUxHYsGgfdlTa0ybz7L6utG2IPzolPlJxEUee/FepHp@UTs1RDg@EPjhH6lKG4AJpSBkJY3ApwwRcIzdIUxYzcIu0pMzBnQwL8IBEUpbCSliDrgwbYBArZQsyJJeyA2@O@gc "Python 2 – Try It Online")
Just a simple lookup without any imports. If it finds a "special" character it prints the first character in the string where it is found otherwise just prints the input.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 30 bytes
```
{{S/W.+//}(.uniname).uniparse}
```
[Try it online!](https://tio.run/##AacAWP9wZXJsNv9teSAmZj3/e3tTL1cuKy8vfSgudW5pbmFtZSkudW5pcGFyc2V9/zsKc2F5ICJBw4HDgMODw4JCQ8OHREXDicOKRkdIScONSktMTU5Pw5XDk8OUUFFSU1RVw5pWV1hZWmHDocOgw6PDomJjw6dkZcOpw6pmZ2hpw61qa2xtbm/DtcOzw7RwcXJzdHXDunZ3eHl6Ii5jb21iLm1hcDogJmYg/w "Perl 6 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~61~~ 59 bytes
```
g(char*w){w=*w+61?*w:"oeaUICuic OEA"[(256+w[1])*13%59%13];}
```
[Try it online!](https://tio.run/##dcs9a8JQGIbhPb8iHAg5J@oQRaGGVkQcnJycrEM4aMzQWPzgDBLox1AsdFKXTq0OpYVOrYtrf1iUDnXpvby8cD23LkRaZ1kk9TAce0bNzblnchW/5pmqGPXDTqsxi7XdbtZFVxbLlZzp@j3l@SWnfOb4pV6QZoO/9nocJ9OBFK4zce3ChS3yRgWRPJ7UugrjRKq5ddpo9zIR@eP7cyOUCv6VW5Q7lHuSOiYPJA1MFiiPJE1MnkhamCxRVihrkjYmzyQdTF5QXlE2KFuSEJM3Eo3JO8oHSR@TT5IYky@Ub5QdyQiTPcnsF1IrOwA "C (gcc) – Try It Online")
Uses [Arnauld](https://codegolf.stackexchange.com/users/58563/arnauld)'s formula from his [JavaScript answer](https://codegolf.stackexchange.com/a/200584/52210).
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + Core utilities, ~~40~~ 32 bytes
```
iconv -f utf8 -t ascii//TRANSLIT
```
[Try it online!](https://tio.run/##Hca/CwFhHMfx3V/x7YkwXLcqpSTDlSg/Nss59@RZnkfuzoLyYxBlwmLyYxBlwmL1hx3fz/J6vztu0ItlJjuKlWf0kCxJUShzZIXkBp5Stt2sF6uNitOMJwlpBqRIaRLfqaC/MziHC7aIXbIl7Aqu2TJ2wzrYLdzBPVvDHtgW9ghP8AwvrIu9sh72Bu@sj32wCvuEL/hmDfbDRiJPXUP9gdKhJJFOBWmyCsRta0FJRcmM7/UM35jkP9l812g//gE "Bash – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-pC -MUnicode::Normalize=NFD`, 17 bytes
```
$_=NFD$_;s/\pM//g
```
[Try it online!](https://tio.run/##AaMAXP9wZXJsNf//JF89TkZEJF87cy9ccE0vL2f//0HDgcOAw4PDgkJDw4dERcOJw4pGR0hJw41KS0xNTk/DlcOTw5RQUVJTVFXDmlZXWFlaYcOhw6DDo8OiYmPDp2Rlw6nDqmZnaGnDrWprbG1ub8O1w7PDtHBxcnN0dcO6dnd4eXr@b3B0aW9uc/8tcEP/LU1Vbmljb2RlOjpOb3JtYWxpemU9TkZE "Perl 5 – Try It Online")
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 23 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
A port of Arnauld's JS solution. I/O as codepoints.
```
Á7?H&U^`a­Å8`u cU/4&7:U
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&header=Yw&code=wTc/SCZVXmBhrcU4YHUgY1UvNCY3OlU&footer=VmQ&input=IkHBwMPCQkPHREXJykZHSEnNSktMTU5P1dPUUFFSU1RV2lZXWFlaYeHg4%2bJiY%2bdkZenqZmdoae1qa2xtbm/18/RwcXJzdHX6dnd4eXoiCi1t)
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 39 bytes
```
x=>x.Normalize((NormalizationForm)2)[0]
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9WmpdsU1xSlJmXrpOckVhkl2b7v8LWrkLPL78oNzEnsypVQwPGTCzJzM9zA3I0jTSjDWL/W3Ol5RelJiZnKGiUJRYpVChk5ikoOR5uPNxwuPlwk5Pz4XYX18Odh7vc3D08D/d6efv4@vkfnnp48uEpAYFBwSGhh2eFhUdERiUeXnh4weHFhxclJR9enpJ6eOXhVWnpGZmH12Zl5@Tm5R/eenjz4S0FhUXFJaWHd5WVV1RWKWlycYYXZZakaqRpVOiF5AeD3a@hqalp/R8A "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 72 bytes (53 characters)
```
T`À-ÃÇÉÊÍÓ-ÕÚà-ãçéêíúó-õ`AAAAC\E\EI\O\O\OUaaaaceeiu\o
```
[Try it online!](https://tio.run/##Jc69UsJAFIbh3nvJRSRhhYgaBeLfpCCEVQMKigSUCqVgdIYKaKhQCgZmqJCG9r2wmHXf0z/facl21AiSpFSmbzBgyCdfjBgbTJkxN1iwZMWaDXu2BruymWb7wheO76rzgrRQyij2m0li0uedDwaWzTAjFHeYzTmMjvLHJ6cuYyZMz84LxZLH7OLy6vomYM43PywqIcuqVGO3d/cRm1r94bHRZMsvu6fn1ks7Zt/pvr71DtQLpmXbGSGE0h2Np2nZ07CqEoZVKaUSIw2maS3@x/4A "Retina 0.8.2 – Try It Online") Link includes test cases. Explanation: The Transliterate command has some special characters `E`, `O` and `o`, so these need to be quoted. To avoid repetition, the `o`s are processed last as the last character in the replacement string is automatically repeated. The remaining repetition is one byte less than the overhead of the `T` command; compare this 72-byte 58-character alternative (which also corrupts eth and n with tilde):
```
T`ÚÀ-Ã`UA
T`Ç-Ê`C\E
T`Í-Õ`I\O
T`úà-ã`ua
T`ç-ê`ce
T`í-õ`i\o
```
[Answer]
# perl -MText::Unidecode -pC -e, 14 bytes
```
$_=unidecode$_
```
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 82 bytes / 53 chars
```
`áéíõúÁÉÍÕÚàêióuÀÊIÓUãeiôuÃEIÔUâeiouÂEIOUÇç`k∨4*‛Cc+Ŀ
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%60%C3%A1%C3%A9%C3%AD%C3%B5%C3%BA%C3%81%C3%89%C3%8D%C3%95%C3%9A%C3%A0%C3%AAi%C3%B3u%C3%80%C3%8AI%C3%93U%C3%A3ei%C3%B4u%C3%83EI%C3%94U%C3%A2eiou%C3%82EIOU%C3%87%C3%A7%60k%E2%88%A84*%E2%80%9BCc%2B%C4%BF&inputs=%60%C3%A1%C3%9A%C3%A0%C3%AAi%C3%B3u%C3%80%C3%8AI%60&header=&footer=)
The bad version, I can't figure out how to port any of the good ones.
[Answer]
# [Nim](http://nim-lang.org/), 45 bytes
```
import unidecode
echo stdin.readAll.unidecode
```
[Try it online!](https://tio.run/##Pcm5EsFAAAbg3lPkCbxD3Pd9d5FdsiS7kcNVOQrDjAqNylEYZlRotP@Drc7XfpxZUjLLFo6n@JwRqgtCA1Q3hOJ6hPGgQzWimmbwn1KqmGOGJRahMFaRKNbYxOKJJLapdCaby@OAHfaFYqlcqeJYqzeaLQ1nnHDFpa3jRijueHS6BsOz1zctLvDBC2974Liej@9wNJ5Mfw "Nim – Try It Online")
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), 17 bytes
```
($args|% N* 2)[0]
```
[Try it online!](https://tio.run/##VY9LT8JAFIXX7a@YNMWACQTdGhKhVMUHIAVfhBgolwIWCp1WUCDxsTCauFI3rnwsjCau1I3b@8Nqh1bEs5uZc853pmP0wKR10PWwapjgiLXYwAmKZVOjwwBJz5L5UDFackY8L1pALcUyG22NxAiTEMdTPMFzPEtIeJGU8RKvlpZXUni9ura@kc7gHd7gbXYzp@QLeL@1vbO7V8ZHfMBnfKqo@FIFfMW3mlZv4HvzQG@1DfzCD/zsdE1q2fh92OsfHQu8CP0OqBZUJ3AhzpSQpKQsy4yY8oCuPFrBgzFVVLUKAIzS8CCuPILtA6KRSHDqdxEd2ppVJ2EyFxoGBjw3fnOxU56iuF/iia/JQOb5P3bs40QTqK2zihmxRoRxj8Bzxawi2dQyWplK082UyKIL4xRbVYFS1uXHwtD9611wLfmpPeyc@633E@7diB85Pw "PowerShell Core – Try It Online")
Inspired by [the C# answer](https://codegolf.stackexchange.com/a/200641/97729), thanks [Gymhgy](https://codegolf.stackexchange.com/users/84206/gymhgy)!
Takes the input as a string.
Could be shorten down to [14 bytes](https://tio.run/##VY9LT8JAFIXX7a@YNCUBEwi6NSZCqYoPQAq@CCFSbqFYKLRTQYHEx8Jo4krduPKxMJq4Ujdu7w@rHVoRz25mzjnfmY7ZA8tugGFEVdMCV9MNChbRyMANi5VhiGRmyFykFC@7I54XKdhUoZberpMFwiQk8BRP8BzPkhJepGS8xKul5ZU0Xq@urW9ksniHN3ib28wrhSLeb23v7O7t4yM@4DM@VVV8qQG@4ptWb@j43jwwWm0Tv/ADPztdy6YOfh/2@kfHAi9CvwMqhdoELiSYkpKUkmWZEdM@0JNPK/owpqqq1gCAUXQf4sknOAEgHouFp34XM6Bdpw0SJbORYWjAc@M3DzvlKYmVMk8CTQYyz/@xYx8nWmA7BqsQxh3CUOO5Uk6RHJuarWy16SXKZNFDcYqjqmDbrCkIRaH71zrvWQpTa9g5/1seJLy7ET9yfwA) using a filter, but I don't think it is allowed?
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 18 bytes
```
»æ₁s≥»₄τ?28⋏i?96⋏+
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%C2%BB%C3%A6%E2%82%81s%E2%89%A5%C2%BB%E2%82%84%CF%84%3F28%E2%8B%8Fi%3F96%E2%8B%8F%2B&inputs=205&header=&footer=)
]