[Question]
      [
# Input :
Two decimal integers `m` and `n` that respectively give the number of rows and columns of the table.
`m` and `n` are greater than or equal to 1.
# Output :
A table in HTML that has m rows and n columns.
The table should be displayable by a modern browser of your choice. Most browsers will display everything properly even if tags are not closed. Proper indentation and spacing is optional.
There should be at least one (non-whitespace) printable character in each cell.
**Cells on the first line should use `<th>` tags while the ones on the following lines should use `<td>`tags.**
# Win condition :
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest source-code for each language wins.
### Input example :
```
2 3
```
### Output example :
```
<table>
 <tr>
   <th>A</th>
   <th>A</th>
   <th>A</th>
 </tr>
 <tr>
   <td>A</td>
   <td>A</td>
   <td>A</td>
 </tr>
</table>
```
or :
`<table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A`

[Answer]
# JavaScript (ES6), 70 bytes
*Saved 2 bytes thanks to @RickHitchcock*
Takes input in currying syntax `(m)(n)`.
```
m=>n=>'<table>'+(g=c=>'<tr>'+`<t${c}>A`.repeat(n))`h`+g`d`.repeat(m-1)
```
[Try it online!](https://tio.run/##PchBDkAwEADAz0jsRkhw1SZ@slWrSLVSjYt4e4mD48yqTnXosOyxdH7kNIm0CemEzLuoBssyL8AI/Tm8oC5ml75lT1XgnVUEh0gzFYbGv7ayxqS9O7zlynoDEzQILWJ6AA "JavaScript (Node.js) – Try It Online")
### Demo
```
f=
m=>n=>'<table>'+(g=c=>'<tr>'+`<t${c}>A`.repeat(n))`h`+g`d`.repeat(m-1)
O.innerHTML = f(2)(3)
```
```
<div id=O></div>
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/) with [MiServer 3.0](https://github.com/dyalog/miserver), ~~31~~ 30 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program. Prompts stdin for the two-element list `[m,n]` and prints strict XHTML to stdout.
```
(⎕NEW _.Table((⎕⍴0)⍬1)).Render
```
Example session:
```
      )xload C:\Users\Adam.DYALOG\Documents\MiServer\miserver.dws
C:\Users\Adam.DYALOG\Documents\MiServer\miserver.dws saved Wed Mar  7 17:19:40 2018
      Load ''
Development environment loaded
MiSite "C:/Users/Adam.DYALOG/Documents/MiServer/MS3/" loaded
      (⎕NEW _.Table((⎕⍴0)⍬1)).Render
⎕:
      2 3
<table id="id691498143"><thead><tr><th>0</th><th>0</th><th>0</th></tr></thead><tbody><tr><td>0</td><td>0</td><td>0</td></tr></tbody></table>
```
[Try it online!](https://tio.run/##7X1rbxxHkuB3/oqa9oyralTsF6lXN0mBoihLXom2RVn2DskzqruLZFnN6lZVNUm53fpgH7wUVxys1zDs@7B3O54ZmFgYGNza3gEEGAvI/4R/ZC8emVVZr@6m7Jm9PRwtk91VmZGRkZGRkZERkXa/O9t5bHd7O/9xdvR32/9hnP3287XVd7T3yvftVtcx8PvZyXdV8@zkm5pplu85XsfxsezM2ck/abOTf6jc/Vur2trqyur6@vK9v9XeXL53f11746Z29/b66r0Hq/e0uXJ1aniNdtcOAu319TfWZqjSSs/bd/yQH2mGHWi21t61fbsdOr6277TDnm9qYU@zvY627ff2tHfv3qEvy2/eKTN@uw5@0bZ7/p4danv2Y83uBj0tsPcdLdi1@47mevzS7Xlc53bIZVyv3R10nEDz7D0n6Ntt@NgahFoIMKNHmu/0fSdwvJAgUAvdXuBoHTu0CdzBruMBUlqv9T5gTDW1dg/Ku14QdycAsICg7QPsXqjt2123AxgQ8tQY43a9F@4SAvgce4o9RvwDqlqrVn@FzQddBygJZR3/wA0cSQs30PYc2@O2GvQQft4PAO@zp78jEiLcsIe/6bFGjaTKYJthD3/j45kZBALsdPuNs0/@Af7evQN/a9rZ3/93fNrvw7e5eS33BzF4AJ1HytXL1SrDCntrgz2oNYTqN@8hsPqVywTP2Nc8k1t5cPO2tu0eQkmA8r14CxhaNbNxdvyxx@2ffDMikB3nrUEvdBCovrlZ0gHAPR3@HH8FXzc3@Tv@hQelkh6EvttHuFzbDe4521jXqC5CE/DcPDv6eq5@aRHq3binFMRSlbOTU@6H72I3zp79cHb05dC4UIFKm7qmLxKATz7Damcnv69T4UFAPX76z5vwGP6cnTzfDOHviz/VoGjVChHSyfMKlpDPEADRsG/7oYv853Q0LCCwXgHuQqhVrX52dAxo1aofAsYdX@3auuvtdIkyRm0RKAdSwRI9rC9xb@Oie31RtEoAv6N/VFZSRpbFOUttNxpVGosnoopgnagoDyIWbcEvfVZffEBdFWPaqjzAEddf/EnnIT36ukIFL@jQ0weNB6LY2dM/Ilme/fAAmtGdVd2sPBAN7IWiAaMedx8E37@eHZ0yLAC@6FOrIBS/b/iyad9klOi7z@CIN2isTp7j2@EoRgweLRowNp9iAxYNE35s4HDxoMl@Rd2nmb4GM5wQ1Ms6Uel7c6F69vQPKLRX4rItZweExjtuuMvtA5/8zpBDgC0953IaTdNbzqEYAOTSu@@WV@/ihFy//dra8h38tLo2o0xFMYGryrPapbPjP56dPK1d@hCaGM4kJ@9cDehXXkBmaRj6bY9l1q5zaHectrtnd2PpZgQmCjPdgsLPzRiJy5cvz6QlAs6J789OvgV2Rbwt3W61O862bvG35esrN1Zv6iMWFY1t1@l2tP6g1XXbKNB9mAGhP0Bqnh1/pONHvbjkNgh6WZQ@jynrDbpdURQ/6jNCfs7@HD@iNwGsECgLhSQWovXo7zSaxr0@vgxGUk7bvm8/boaP@0233ez4vX7TC5q0Gvn7TvMRCrzmo37TgYFphjNS3lItmKC4JkVQxCg0ltttXDkSPZ@JGIRHzagt8MynmmYFKGLoq2u6VquZhn4X6ts7Doi5ZWrIt72H2pJW003Zxn3f7msqmzVub0fCJYGO/MHe8ywW2NMM@uQfqyBwtfqHQAFeE0AUi/fQT2@w14KlJQWqse50cRmmmYVjSRX0dKkVO3DuuEGoXS3Pw//1mZy1K6IHfLp/6/Y6TMapKNK2PVziWw6qM6jyRKRJNA/N1nKa9WlxreLQvcEaRR7FGqvAzEW1QUjiIme9vowTNCgA4HWYVDMpqERcYB/sQ8BjZnC/c0ZN39BJ6J26bfjGK1J@e8ADYoHIey3hGbULbtuEVUrf2AKCQi/yRgY4I48eyGbtPMBWDlWsmJNQ4ns7rGF13KDftR@DPAB1NBi0dwsaqi9KdkgXWPY62Fd4/1VBZ0URsX4ffzyOIGNeF5GhmAIwUrB2Wrr14lTImBenVhF33N6eyQGC4/yZvqXPFBSOWSgrB4xoSlVMsWQZsGatrkWiAyBhLSkWC@QjyD8X1qIPnL@EkMS3oiFtVuwrQmAP@TAqhD8btS2QpaFWonaCEsDpDUChJo3@WrJoHYoKtKjJeHeSKji3pSG216B514PFFWqFWtexO4iFfnbyWx150/U6bpv3JLBDCn0HdxewlbL37fU2aDAhSGbcH@BewNNob8V8HjUW7WyA2Vuwb9K6KBB729oGynSL8LNQAh84MeZuaOH@xKP9z9YUy0qDJwOKY12QkPUp8QVVEhB3vJ9IsNIjlPoGUTZuHymDStsc6ENymKg3nR7iyaWjHRztbrJUvzYzxcL0My1K2Ab2/u07dwokBslRVjmycgaaWYSNiBiwbc3wgrQc1ld4wTno@Q81YAfaTbth4HS39VgVu1SrIeKptSwHlUf9MWtPnoCZas0pEBKT1hmc0ABeDuHCuGUG8eDyn8GyZMk6FRR4sEIZpPzHeo0VyUJ4gb8ysnrCmoWvn0TMJbnj7Pj3@QtZlsETghXILmSyFPm88/N7YQ@YwJmZYrFDjHCC5K83uBtiCj8BjGBP92W833hxqm8PPFJO4Z3zfhl@/9LQDYvkjYmo/OIXv0BxqL3/1sDxH8NYwdRaf@y1twe4vTflfLaELAp3aU2lJjyUXAfQjCYb0QAQtIJyqeuCjAPdvEgjIAwWcafF4wbDey6N6Gdd/FOjl9coibSzk2@Aa4yIPcwfv6iePTuCPeIFhQdnJq3SIAKPvlSXO1ivSd/6PbRy/NXYSRZBlHMiWrSVYolF9n0yUYT@2547iuZxv9vc9vxW2ARCNVvNQTto0lZysuhH6r4GSxfJI8UQRpY8se4qS5KYb7j3IETgFfy2AIHUlIRt6XFLFDg6JuRQgpY2K7SHfHtlXavVtRqsKXPaFe1qisiw64eKtO/fhEmJRiH4VcFf2/gL@X/Tx18t/BXqG9zCybdUcWscuVXsavUrC0AsXiMQp1RHeE4OL8HuXZgMmPDpPUG0b5c2iwj7gQ7MgeLr@KON6pZB22f4tWxuGPNAxNolED9/aFUAibFIE7EBaYA7iT@gICy3MG7bHq2vTVAh4rFewXmPmx4acB7ZxGBve6KByJgg4GSWqSewzJXZOILvQVYdz2nzojY0ikuz2CSLgvfY8MqY4Prf7nXkzHyf2WNQr1cv6xaWs/RSQ7cAEC9CYYD9wxf5mqdUNOJ1cW296TWJBKxhynmeQw0sNQvdHYAWY7t@DnVia7NAOKX04HDXY31nJhaOlj6MJvVNEKkesCCQFN6srRNZ7szWU/tMEgmigT37obPOmHimpTd0TSFgRA61nqSEpP7aOkhnrGvpcU3qrMJLgJkyw6Vp0UOrogHM67FxDFbhtXUcaTbqaMJgk15YFbTS0lchQdT9SAuYyxO2xtq6ZGfqQ2qeKIirs4YUthErFbNkLMEZ@ZmfzzyPEmRGlnkrUsFvghZPJANm6UqmsIOg13ZtVMtpzRSzZ9@GZaDVTQwM0vMRrOuI0NnJ/0DbIi6UKTpFe0kSRGgCfvYDW9iHLbRGo0EbRdYTNMwB/QHSe/ooCQCxXe87gFdXleUl0rA3tb1BQBaPELrq4balp9ntNuyFVPOCYaDAhpmomxXfRPKRHNOLaPyWZUB5KPkWkrGiC2NAhsI088MejCUdykzek8hKQ0GVtXVdmICJyUDfMHSL9cXnwBcm26v1UQQ@QqHheJ2MUe8vZzekk5u4873W@@q@mM91cJ1u15qtWBTRwRDwOA5OkJLPOHzhwIcp7YZi3Jjd@DhLBeLIOjTY271ut3egBcgT20Bgf9B1cFcKml0Hd509MoDBGPTDeC84ZkzEcq@sQhn7gWKRKzDAyXWFejgLOt3OYA82uHKbYcuNRvqUUTdNWHTEviJGYer9a6zaK9OFd6TFu08JHWT4YrvGqt@nTAY8WUI8ngjdAdQYodCITVOIQwoLR3BtptBqKWlUH0ci5xAGEEVNu9sLcHBHRAsQb/Js6tMkPfCH@U6uBX3QEx2YfBJpt58modivwK4MOqoV/5BlxhPb6T37ccv52bu3xd3bmtw9kE@/N56IToIq9VWivzCabO2Nj36ygEgfXIT1ASDm78mwqaNjXPAsWu4stAPk7GIkSscf0b@PcwDm7k2Q6iWk@s9NxxLTsTSZjsuv804iQaj8oRcC5lpOLwyrZuIBJGnDxx@3MofEMVABio49hUEmFzFcCGktbOVRjQwy0GJRt1IDFdUj5WVMPXyfV4@1nTEVqcCEvSeXTM@@v7x5NrUQdZyEifb/lRVp8vqz/BMXnL/cYvOzLjQvLT0mLS75C0t6TfmZ1pOX7sWkNeQnrx@FovunStSfXZoWSNIJUlTUYqv4zFQCNCM8JwnOrNBMC8y0sCwye/BMkURHYbZnBw@bwa67HTadoA2zLGgOPBetIV3YxDdhUxc03ebq3ZmYhGT/wN1@yho2zcE8bn7pkBU0iVgokRxYvYtbKLmDQrzIPn496NrBrpbHFikO2bP9h1oJt58lbTNu8PryDc3dNgjg0Sl1FQBLvyR8bJJzCNvgcEsXQUxvCZlC6nEQGqIRxEziLJObfIJuNtRehWELAgsLX2vb88OBsDX0vO5j4UknSgHheoNuRy4Fm0oLMEAIY6AvRtAn0uVtz0UzksYjb8BG/bHmOSAB9no@CtsejhnMDPXEQjABcha2s/kEGh7TTsf10Z4kauHaoRrCDfFcGv2ElJ6b167WtfnLIK4jS@fVDUmpk2@VWlvpoyigfTFGKcn5OEmBtDKOfC4clSrk0IOOSiPuNrSRVlAzCof8ATQ3ENZW3EPh38SvkKWxqaMvyxegnfmtKU3/NDki36j8E3TguhxFOtJy4h9k2A0XUayNs6by/DSe0BSp5AoX9eQemm/MZE6bEsjyFJdrkZhNOa5XBW0Zuli@dGv1bo5rVkLUkYYRKRHR@tsMD8Nm19l3us2g33VDYfsMmniovhfsxDrZ@sCnE3A6qh6OdFaDxDmztuv4ioV0tcv8TkcvgQOt2eIoOrbEEUKvlFUbTUIcAmIk8O47h6EmZw5hiqNwYRPeLwQooTaGujmrfN8aRU1AyQsV6hcOrmXQe6uBJ2RfY3kCtygZF7qrjkdEXKN2of6hRyd@A69ld22vjZ3xya2459Onh04I@pzesjvCsUCPgSque5eqeMZsELij02qkZRAiclj5fFuchhM9nqIy9@LU8H78c92s4wkA6gen3LPjj/Qm8IjsM1bGqYumSXROlA605J/34pTeJw3LAdpVV@32rha1rDApfFM5R1ii0oYOYDHUmbAvXsYv8Le6F5R1y7N0gATw9HzHpFBHfXQ7XX84@vHPBrpmfgZEe/oVnwrcfJcIVFHPGzrOtjfGeyU2@mbMjBGtopmGCN2Fp9qgL6z4dEKaMtiea4k3EnZcHP8nkQcpYRFPc19afekk@734JJtFqCyY6QdPa4QXn3iwj3FAmzH2YKfjC5qNst/n6seQ3WXRnsx@nWxUTlmmY6u05g/rqEOyFgoVhWH6@cgXIKLOyL6QWq9w3To51CS1a9TW@k30ZwGZlZZitEGKR/IeejKi7sKeOQAWZrCj2pTpBZ/uKkI70b6qCQA81FnR293Ak9@@OLQ8@VYno/KnUovjRaOfsSE13tl1QetGQEu872OnnJeAyuZtADQbOe8js1MDOctGTBWc/c5eP3zM9A5wm@kc4tacHIM6PU8PWSmCDXYsAHZF@EXMGEaCTsjYYrVj3eYzeSiu0jex2YdV4sDtdjW7ewAji3t5cosCLfONtVXN4dWEtLTYa8LUAtoYSwRhm4w72saUqxB6gIkjmj3Rk@SKEw1Xes1hvVhddfhJvO7o12EZ2BiOtgC5AD3M9PQKIICini1XH2WZEkAXadSPvk6uUvlzg8Tyi9OcdSHqh6xoUKTA7w0DFUbC/UvYYr04TR7OoXxKDevXOPEBN9NUvRNg/JPlYBuRapEnl@oZkXvKIo5AkucisddbUtSFvdfJW@VNGNU9h06sAHwzBJngzigcjrFDKLJxrqM2ZYPQ8zzHx0CewA1CZCw6i9vrAbuxB8xsED7ukrxh0KpvIVpOep6j9bYb0ePZRFDRNrCz13aUt2kTEXriCfdD4EfhdRO1FqhwgX@gSFyNGqrQMWxcbq18vQyFYd60gdW3B13uEeiTXdtX3OUUPAgAaJC7MOC2bhp6S9eMmlbX5kxTW1rShrt2Y9hqbNSsujW3NRoB8LY9gJVa1KCIIn3X1tXZPNFbkKJxkIry2Rs@bVy@rtCbF6fxK7mGsAeh4jef2PJLz0rJbuRW4vsZD3XpVcZ@QbHhDgibOYfAhe7Zv8NCp4@GaHzA83mOT0HwKejS35eURVq2h6AwslkLipqWPtJzGuADdfKmAnnbdR@iO0HMAWLAJ5iExRkE@ftpyr4ZZSgZ92Da9R20tgYZhsjZMgnyocXMYkc1k7Qu/FDgKm3UF3lao5hSnZ5ZoeuMbSVJyWLfZCZquiguXi45BPD@NAsNf3AFdRmlnLfksyCYo28uRB3oz@RvndmxoIYlyKeioJgMVPgQhiak2CAhcWsLIgTNRF0caVvUUhzFANw/U7yZJ4zE5IiakYFhWtRUWNRMwfY6AT4raaGdYog5wQfTNKf2ROvP5EPOMEdUM@nhkfXySPgdsrErMzkz@4U8kyGvPYDk68vvat5@v7nv@K3m9l7YJJnaDEAHPWx2miQCIgnN0p7jUSuxx1CQWJGCgRuSGwjuNGITFCos5PbUdXGxCtwOrj4aoxC1AGXhrWt3u1Tad0jrmdcQvSBeqgzdOXTagxAW@vdhZQ1oZTWV18LApIPC1OUwXUPHtVPXdsO9rlqShEtnioKgHkwsOX7tADqj0IA/WYsKPBQOHhizsiWcce85eNCUdcyNQgDpZCAb70deSujSy869w5E@LgKQIhQJmpAiCGHJEMsBgzsNeTMnPF0p5k4vwSIh/TAJAT0RDkM@gw1uEsMaU694eYm4UEFHBO7MZAWRQjsKUarx6IAq2nH6sDbULPROGuw5ch@etGZHR3hdWLQ6ad9swFIOg6B8oq06NRUrMfwpyG6HnsRjWhD8hezMxxI5ZaixiMELRcUQqI9w2FXQwCE8/hiJjSs9gEW5YOVVJzb8jJ2b6oVxZ/EUijlfTpYcoIc4LbQOq2QAeJ6RmAp7@AiV4ZMFnzpxfxjYVP2Yn8LiWhBRltpjEvXnmK3aZKsHhdRQBI6@3euhqhk/2MEHpvbGPSwXkw36pEcygmupGkiWFzLsMJ4ViJDCExuoABsmnFAvTuWMenGagpZDE4PGzTTEwKGpLjtqP3nEMpTnjs3PvFxnMuBSy@FWgRve0KbIVco/oR00P2iGE4U2c4HIAmFrvLDxsiX3Ynj@L6UC7D36IGX83gEuibjcUQ0z2vNwEgeRfUH6W3aE50C8FUquoTYvoNAQSrOydOOLDz9nNeH3andNAN4d7HnaLsdjBdIQi5AQIdGUxC/GKl7rDgAgrPO@e4h4YzcpysqOgmEGfdiaOx1LO9ioNbcoSo2Ebkf4MLB7cwKNHP8Bmxc5G9dEXFMO6OtBNKdzIq5I1b1S1a6IdAIiusnkkryLwXh0yzYX65xK4CBuBDZm@SClwI68LV@cGqK2iYdGxx/pKjv7ho2x92XFD1OaINHC@TzllGm@OB2SkxWumQQ2Xn@h/CefHUyhrJH1JKCd9BtiBL0AD3G7fNjrNdsDH3bscQQhFoUx851g0KWouYh5eAKg@6vfEYzF4BN1YTTd0BF5PdwofUgpGLRu4/PSNBoPHV1g1gluYFEgyfJOaVS4vOKiEURnAEHAzz6Ln3EV8ThRXx3HuHwSCdH6giBmRCXiV1gEOvA24W90/DGrVL5Zlt1GRjI8edgRmIkRSeBf1IcJ/ShiTgAgTz0pdAlgbIdsMryWFqT53DIFm4GIJO643yPF6eCc8ZO2HimxchOkSNyki1eqnJ1b0uvk42nb2nKnY9jagTmlO7Vt2PYQNWFMWcFqMk9UqTTjt4YhVWQxiWk1eo67ZNR4caclpu5zepx8PTIPUmZBWqjIAigNguIrpc057w@O/g3bu67Vq7VapVaPSXK4h6bdIQrzEWc3ES5toK01W83Q3mm2nJ0mzufYsPwmHkQkPNtoMYPa5xx1ipAhuohICR3T8uTEEwIe5A2C51@R9YacTzxhwqejHY56VuOHMTPRAfCF7fFkfUB7TzYTVXD9bffQGBY62n1bBmtB13GTa@9U9IWKjKpZYqyAGNE7fkWPkT7Rc/yiv6RzmjIfEwexDdXTLG1NL/Y64@EFpC0d422dxRIL49ISrD50ngSzPPZCMy3H6@S6ok2B11YWr63p8SLbeIzWsu/jDnQ8ZmkfMoaK5Mfxsox32bEpTotEgMTAYjEcVFRbHKGw252OJvBhxi6lmozS7pD3l5Y8MkBpe/xRXkcZJQEZEDNaZyff1vBEvabVKxJYq9frOran424Y0X@CdGuprhYxRPhtGYmemC/jCEfLAjkUed6F1b298ZizjxziJuvGlMO0Y2Qfr10GraalnxfjBIOtPVi@c/sGMZjCVLXaVO5siWQzKNGg5SZqk823QKL10MUjjjqOxRnLPjvkszYSaJTP7WfKA5BybU3H9StpFVjvgHUbcWbC0TJzCjzNyYWYoCRD4OOMSuUhFpJzjtTGWGdk/XgWBJfIUfTsB1x7UJGIwZDA4swyaL59TKfCFwGYQeicfAuzDs808dtM6tRAuq4ANFRzRzweOI8zbkQYxm4kAoIlsY6@FOP24hT2rqQ5Yd/i3ZkiAEiYSTynxGY4ysFmWIzNjiM0IcJHKkWM0UjPOJ/v8QGumMvoHoOzG3dBtE6lTmae6IsoNpCYysH2W5bx@rtsHKN23iIXwbwcCkLDg1JK9fyMC0oBKg64CiSvndcGzFDeVdxGAydsBugw9bBJfozNAUy1Qw6nbt5yDsWZZBQ4Tbn/OEJUUSPyvEIjf9B0lq@gK/fuz37YyziH4oEMn0sTPkgV4WCZ8taMw62hD1hsYenVkp4j3KCz3o7DmQljT3wmQez9lQ7EfrUbNkG0v7rDf@y9Pv3FSd/UN7DJVPR1RounU2rVIYkw7m4@GUinz25qhYibj7QLxZeS6ZEX861SpLs5iDwlN98@hB/hIZ0@LuRUbWPSnaXKY2klORtWP/lW@kIC5nya1TLJJbKW6xSZ6d9h2qEx8mcUUzJ4qPU4/SXMg34vcNVo43FsLwUELKBWxXiyp3o@5kwJOWtJh4ZPMAlwSpD/NMyRR5xvICeHgIwlx3nxarnc1KDwAE/Rg8iN7mFk2IB3OPTNV185FHHy@sryjStX23aH1x2ZOKA4ZQAdHyKG6J4bub8ZaXZlNpV8a0HDpgETpPSqbl2BUaJ2VMskjmE0hPAZWzg7@XOSPaErS4jc03/eFNMXR/vUmOVxh5UGP2FVXGdaMylvWhzXKDg/dcrFowANKDNCjMxyNDI5g4dSQxUg6E6lDBPFMh/QoRJFM7fs9kMq6JCNIxJIDEXf1BcBQGr7Jd102rtO@yHZ1PYG3dDFg3jpyx3SxAMgS9IbnbGJYIB64pNBxsHR2vF7gz5@20whwH@Pvg5BIdMECJHO1XfimOzNCPcEMSJPe3IDwv1YE2U7QOGEADKFkUhKikq4yLeq9JZcizq9Ae7JOYGU8DHvOF13zw1lbhIzhXo0ApSeNdkS/U2TJqdfJWVMRGcYxNEp8lzciUS3MUOU9CCEzUfWM7jAExg3KT/RExg9yEDT@Lq8SMlrKImKQEdaDxMR9QIMNg@7V@hirv/WS3kMq77C0v0q6ygskMOqtNcFIUS2g1z/q6KQunj3meODTYfDzcO/nPd1Hs0Zr782yc/ppJ3afY93yD6f4zUuzVVrWB29OCX6iz3GdH7XhxvN2habJf9hGGeGPf4KHygu2A2ym9AyxamLFtbXaPeDG2OpUnoSBQQaNzCHDQyp2hJaZhAbgxMPYdpVGkna9aCfN3sF4PhFhh0AUd9iO1LEsaKZumwmCvuyKtZhlnf3w31c1xIbAVjlPdxXqrQkI8GCvig1c0/kP8LMx6d6hV5k2aWHLNBa8pBVWjD8UgRyqwa8lt6QaDz4SMLIxzDaOsm5hatHM45OolQuA9bFabvbdx1KFG4HeLDEpzxkzFpSaCgkKnKQgjjBpi6zQDj5M25coBdisy@eJLuDoCpcM9Etep7bN17Leccc7cuoix7v8CkJSQs2@rFrM7nY@rYXoA9K3Fllb3@@7TYNJ4IXz4bT7qyliXNhSVijlC10I2FbwtmAFEvtsQUAoWRyu4ioMgNK@si4eEFYlxKb9HgPSG1o@iIbL4E69YULFW4zsccUzdEEkxA/TeSoSe1UVPWAPRsVB/@U050A/hZbV5Mb3HxvbcwYiMeij/tk501ssHFjwrkbYVXYFSdTnV45j7pkysqhrjxVJ1tHPg2Vk/Xc3LuCK0hAbW2wfCJJIlKesRaSb9/INsHGjTFNjIaFTeQbLRR//4imZJ0g0rECRWd@QN@sEYGxwselAqxyDA/p4/vITpLY8SswFNsHPjHH8IYQB2yfb@jW@Bw2eDqRdK1@O3S7QeoUi8TQ6L7vAMcGaClsenuwxFEQBbtUgUrAiUU5Nw@WFMf6hTcriCNUmdaRtgOYgjXylUZ2jWsrASp08sp@4dMdVul6jlGSOsVbQymzq/nn2XX00PTorFJkH6M0W7yE0WNiNviYU19J07UXZDw0jj8yjPqPXxACqHDham2ph6YhNYpJt3JmJXq4RHnTMlxZz/EMju84CIt8iQxC5kLNxPHOcerMJh7h7NYz54SVMw3SqcOEkhcdbuLRcZrE2TPXmFvXyFUjZtlmN8G0yFwyB@5/NVbV9b8ir3blGbglk7kJhv3kMx1D@P5T@bWrRUOdy61j0oTC9Ov@BO4ubnksb8uYNkUOp@NbQidQIlvwG3BQE3NzIjMH9eb7sD9stkC387tTMBYGS74fAGOkb4RJHkSMLzYcTVlwY2taiKVSo1YfTV26XmrgWjpthdqU5fC4csqiJSxbmrIwJ3ialmyqljCBvjWrtmVhEA79noPfdXpSpycYmjMlhtimNfVwbWyUXi9ZpQ8@qJasjdIK/JqrX7502SqtzJWs@XL9CvzUa5fmL8KvSxe3rBKUK71R2tqKG5CQSvN1WX3Lmq3VryDAwL5RsurlK/NX5y9fvnr5SvXK5St1hFNfK8Hvt7DVX1o1@AwkqEPFjdKD25eul0QmrdJFfFW6VbLi1sjTsnRz/dbdtb/9NdSnDiPqpc1BtboMeFMqLkTkCgCYRwDUQPS@dP21e3/zDuJVm5@HNktziMbd1964Tp2Dz78GcHP1VJtElzUo8jeiS9gRxnNjvl6@eLV2eb5er2/l0D5UvHgk/VPkAwSwZQHbKv3mA0T8EiH@6m8eEIW4q7eulGTvuEdX56nUa4Jq@Pnu61wGMH6TXv4tjFmaiDj2@O7q9V9er1ID2L1quTp/qVa7fPHq5dqVWv1qde7yRRrPrXP2bGwZIVVyObWwPEiLqHSL9rDDS9Vqo0HL3o9/TtZRnOWh7ItTkDYbW6MtcvjHVtG6hvcC0Vf8Ez0ubZZKo6nmz3DKYqVmqbGxNW1haL5RryVK68MPao1SJ7BL5J1VRKFh6YNaSZbLI2tNm7JaHK/L151pJRFTJuzZJUsEmQXiZPDu2@v38TzYt0GL6CaWKVjjoPmqaLIax/j1u5xj6du6NpcpH5Lynl/HuDiPgWWWHugmJU3WP4AfXbt46bJp6HbQ0Q14ohsA@ooZuZQnYdci2LUUdAKg6To2UYe3NVCOrl7lb3NoQeWkR5YhUbDqGjd6dvIvV6umCK88Z6vQUj5w7ISaSkNNpAGql2FrLa2Nh4QSjg4DCf90o6rVEeRFM6peL0DBUyftVem0FtS5FUrMAH3Dc08dfW3gDeuhGPEhCnAf8Y3ASIFoYHRhv2uOYYMEF5DWGsqgv3pNzTjjd5kG9@5Q08TBcTdEjocbLqimc9qLP10FDFXPqWkEV2EGCVTaYHdNShtoa4@aXu@tZnv34TRuvr23xH1kkaOKbmwMrS2zZJR/fc0sNcT9drXNegOvuFPEF7SAddFqDaR8hLA45Ojp7x6lLvtTahENHxENk6GFjxCgoLqkQIr5gO9UtiuqBd9wis1p8@ZE@PK/OTmFlh@ITO8IoT6@fsK3PPf9zztn42aK5WqCmx5lLl3MFeVj4Fql9uEHJY7D3pibs@bnt7Ym1BuWbKiMrgh@aTTSp@FeDkFv4iUJUzAtFpO32B3//uzkf0bX70kmG@r6CEtpOVH6@FzfhcWgBwNz0PO7UVTU5FrnrWGIhgxRTavVY7E/ua5uoOvAnFabn75WqhoG1sOzdhsezml6y3fRwREetwGb@pwZLUOpgUFBRs4@yQROkRCz/Z0mBe411xwP1l4HIxrI@s9hqOx59GCl6e23czLXd1zafdr@4zJn7KRUkNJCkolSdby23Q8GXbJ1UMhqZAIpJ7N2RnmZhYeQE5BdlWMMe2zCjhu3OJKG7dfGQvXsk3/csw8p6Ef0akbJWdYRzkdKnLyIxdkTmXp621GUDub1CJzuPl6/Gp@MHja07DrAuUfaWdpAEREP0HEcgg7YaVdFRgVyQuCO1bNRjfGazGJGuekBhoRPXB6scJnlB9IPuqqk6ZRBXnKAo4sj/1iNFgvjxy/oWsZnR9dqF/Cmx1HFYJRkLXnDAAwMZS/YsTjMx99Bm04NaBAto0pM/bWzk9O1xBCoYZrirktxfwOdpiYudVAzKj1Y2biGHcYT5lO6ePPZ8bW5C@IC1Xl4OFfdyk1aE4UtUYeWanSpgItHZEentcVrdXFxUnuA3qti0GDUXCeTzU6GVqqzZ9agpAFIhU9rE2L9ZP2zk2@Ifd7ur/eAAfGgBfCvU46EnXGp48hUDiSC/v@Wwh5khFPRfQqRINAyDQIXsPPiwEXXPNS8B@1w4FPSHB9mSW@P3alCZTrm3RaacFgBrFAGEKktjf0B6G/FPnTx5p/HmIMxZB9nmKniNmJuz0xeJkC@VF3H3uaJ1aIDAsyZgkAsPLHacw9RkGzT/b8uRud8kwSxLCbW2dM/1PDWRW3H8Rx0Y5AbjWRxPN8ilBE4/sHdCSApz3UeU7aX0A0HHYfi7Q/dvYHq7O05lAPzCtufUa@avVa7xGZYOm@Ch1BIm8P7G2Ucyyf/0LVVDRSreT3e/8CMzExWOUUxgQQwtQBJB3qymklA@b5gnqg0vT/5LNGS8Eo@e/ZDXVGh6mfHfyBgimurhYe9lrbd7dnwB7dkFp14wYhy4Mehpd1YXbmZCvr68YsKuSN5eMzscYYh/2GCXovVBhQ5@a6aPcKyhk@iO4YVB@yjY8SuYpA1gm56BfWqfhklUP2KRmYJ@Ix/r5r34jtvLP1Xr/76xe9/qZtCWTMunD37dxRcc@XLr9fKNfSU/PGLe6YRXTp9af6iGKT/9eHZF3@PNL9H43upXJ1fffGn@px2sXxRww/luvHrmmnM/vjnObNWzfyYo2T0fcdBjoSekyTDayC/iTpoce6NKA8AyTg86EeybFwjasE/9XY9Ei6UIAmvlLrmgSD/AUPhRHB@lAULJ4/MgkXJV9feuM@3kIpcNsw96iw/@rshIUbxVjQyoxenBgaXd@1Zdo5H9@KubbIL5X4ikc9ISh85/OJOb2UVA7BLxNvUrefsbnJog3QNUtnSarg8ccEPsWQ2Niua3bbI0AYCg26fjak/yskXBZprMDODcpPvn0dQeAzTaWnaL@85@y5eX9bQ6vW52mXtlzOvlMXN1uT7IO6svxXudYXDVAatUGhGpGJgeqiWHYAyLEeit01Je3YcuhcEKN7wnUcDF0TP4iadBnUe293eTqTRuT1e7smdojbmFuT39vli9SgjabLU2h2GM2gHMp13rZoH7r6IGsvvkexG5JmQrLzS80IRcArLXhTQHYqeqxBmcdwcXHnxjZDQFRckLnpmBRWi9AVQ28RRU7KhW7CGdB1yt9J15QpPVAL3ybtNFMip@96bQH6@4V3UjQ/q0EuVLtDErHFQTJMIqVHkRBDRjzxS9zBlLJGxKnxQHQodpRsXqTLnzw6BH6M8dZ2ew/55u/Y@XxXMNyuEtsgnnGzkTeGQLQdp1w4iJ226RRRzx9A1NBSJHiOsGYBEXDJA5PIaeDtwgpgRmEpBb@C3STvHCEGxTg8CPsukRkTYsoHLL67hwJS@2@nAitpCP1bf3adLI2BoMQS@mJsxYQgFHL4nbvfmeVjGb7FrL2cq3YZRoc7QNagal5wGtLwOXMDmNWYK0HylD73FtIY9P2wPwiBxyBsAmbEqXXrQ0XAT5JtjJi8mtUmxIgb349nirft378jBC1J3g@UDe/2taMQUYLz1rPCft2/D@HV2nCkhrt/Mgxhf93guYK@vr@ehF99Uu@65/f600G6s5KF2g6QoySO/150OksLouef2xPX0jsbaBvaXw1IR/SeO5vCJhypr4CQMephHtbe3B@SiMbVDEHqtQegEUzDr22s3Vm/GWfIjuULutQh@4DFDdsbDdfGog4AVBj27CogokUWxuJMbnQKglMWHzALnASp2hEWIkosFTtHzwCSxMx5RXt7PA5SyPo4HyokhzwMUNh2TgFKR8wHlDcA4ktJOoBhmDtCIP1eIsZcj1sOlw0UzKo09/OWwdZ0ojOl6kCgYDIz9wL/QNC/Gcp2K2ZhnHt/IiunxoTmbLI0uplMmrN6TKazf4yyV5G0rcokQVFqlKBtzPDvydAPCixc@fo@7VVRkrwnLpTSyjZJuRQ9Y@8q1hCr@O6hfWxuwAdkaVhsN2MXIONOy1N8wSQnaOX77@cqdZZCU4obmfGcm0q0Ow8QdgBOCbmOXmciXFWTatezdgPfWbw@jLdnzhjglql1qNPRMdsqj0wr@T4lcPhIZ0WRWl@dm2Uj3xuTMLM/TQWoiG4SJ/SNn4OLbHYuwTKOGBi@Bx7C6SIlk0ObEeDby7h@gAxV5NEp7od@OK1obRZlmnuc1PrZPxX5qYlN4MKVjWFUTSXpq1Q95eA@K4GIc@7Rg65OAiYssp0pdIt28nv7uYKbIsyu6I806yMnCmMiZd3b0dU2O/He1Cs2a448PprievFoYxViQQnOatg/GMGo1P5dW9nJQ8tI/mChF8KI1bD22lGB2QMqZUtJHhYN1H7Vne9rE7WR9pWRfnBXBspWlQtiKcssrujommo1Wa/VO22SN6JYfW1020@HNUXEbczSAaOdMErLC5dql2tmzf6sV9f4m6fcv0/1qovvT9p@3F1MSILq26HwUEJfipkhQLUjjo@GGZdqpb@dIf@JzmQMSN6txfL50W4QNX8@/vS1OqMmL8iuqixZ/5tjnyuUWdACY9G6MlAje5SMJEt3Ydg8fOph5fsqODOtLH3IO3YbFYj/Vl1UPN9sO9olNY1ny4VYH8cL4uPh@cizL27L7vruz4/igO3NwBqk5FikTFqk4FtmxE6Z7NEDDqvH0qwrALBtrzgEn2nmj26EP6gkylqCjkXUn5C@i9BPS58asJ42@3@s7fvhYA6KBDsS9iJksq25xNTshe2YUGyGZM3wbzw6dgybljRX3v7ieGvVBb/AeYShGKeRPvmM1zVzAmGehsp18K1U3Ma5AE98u34btzKGTyPdpCN1OKHumRcbmg7OjL0HxgCoRAdXrSkg55HobhFCFgqH5o1JpJjdNdOouo8tnT//IWm2RGiu1XVZnWemVXcxecWJgmmnRGV1knVZwKr5/OnHYE8@MnWhgcu@1o7upkfQKfTGqYJ693pfX/gZnb@YC@08@VcqviyPaTl6OZEFoi9RucyMe4cToosm7fvb0DzgpXfOCuzXFig06FENj5fk9JZl97vGZ6kQtJ0A8m5HXUTD0u7brjSiVDU4LOiDnaFqMv2uGzW2gpfOo6T2iBxgoACzOF7ptu34Q3u89dLxmSL@Vg/RHzSlcImbiNDpk/QniCYhvBHLarHZdRG3JFF2obu06dKqN9okeJd5x/L6PokGjahphpxFiaLvC2p0ZNpPu0OyfVVLrUjGyaVB8MZaLkuTXTPwNU4F2ebgbVEBbymEC64GGW3bKAicujQGE6Oy1iFkuTMopj2klbDyl4MjkV3Q8gdPLOhmZRXBEAmmZ4wizumraEjxeLMHnUgJTRhOtMuLEX6assKJ7D9kGja2IgDi1NcUoG8nCbOuUflbT9/B3jIgGTxdLO/hpDz/tpZGrExlFivUkyVrOjuuRXZny7SM53LzOv5LX@@gtIkBIiXJLjBIikk@uuekxyo4MG0oSCJQlevQqB0MmXzmffqLSGArOE76xgSG6UBC9TQAtx6VRZ0MtNrZILWGaWGXkTItt8OiN6saDTkAsvFYhuqaQdYLEEKBY24XNMhI57PWpt/h9sYRfM9yIri3CIabny0AhW@EualUkPwKKx@MvpoOcK@QWY3fjaU6WfbUpI4GXGTOBgl7MBonbN5Q4IhIdrOjRx/yQN3YKcdzAilUhIVDjI/lYOio35OXcv7Azk38FgsgNaPE9DDuZgJv0/QapXOBx6sX0DYV0BH5cEXcVUjMYBL@oF1z1AAWXahPubECwxx@LrG/6uNsZNHgv0ySJcx7BgCRPx9yqoMRIhYKsBrQ7WzOLu5tquqyrRk4yTuMp2bWZ8XkwyZ0GtFQcY9gH/bEvrgN6ccpPYCRhXrBCNDM5rabRR6eDj6muxVHVFJA7iQDTXD0RacsAXARwCcSMqAlzYhsFV0akqPmKHlnLpyaliheokdMhNU2n6d4xnLIL8cQTOWWixfraOQkHCP6FxqTOltnpoE8ajXF3hyjDtTiON2XU/rQTSh556OOAsggT2bWTO6O84dN1adQ5fcRhmBOQiAVajRMoGI8WsYop0v3ULPy2qG9OmpWyN/GdFQh2slSZYuAZv0jKTovJ9JJtEnsoXEfm7v3UXu8c19AUtDTFMCcWw2pORGnGgzE34FXpS4osuXcNRElvYn1DZuAj/aGhocXwc2KZnHyhU8WpRjuqoT/CDdXBrtveHZGNIozvn80zY/JlLE//mTUPqicS1AtV4pPPDAfvoMI3Ju/68LsKN50CFdtt2x7uPuhaM4wdYqXKltdYoZakdraC86ZK92GFnABxrn5J3DB5T2kstSmmK6wsfM2LgI4f4@0/Zu539jHloVwZABHDKe@UtR13H0Sz1OhIpybzCx5NuR32ejGzl4XVMO0SLL506Z5CA6UIXZXNqTEzRRQdjW7RSgHI5A5RK9Q0ZYMc5t8qrGZOTwEne9NGLVIYtsi3WH7LAyZOdvJPvdKMFhsLI3DS4ya2aFlM6MiY@l@TB9VB@b99SKab/4sZymND@aOazmRPlbTisvkna4zrDacbIUlmG@X6@VxsZUHe@ERfk@mdngh719GxfM8HgPxYWiFN8imHCmS2TL6bhtpsuMILTUevKbQuPAHO2@dhbbHPw48F@SLGdzo6qEs9p3d0tzt7GWLql0M@Fcix68njerQKnkb2wjyQBYZB6kBKlinXtaercX@PvhSkY46f4kSW@Wa501mhzVN7EqnZ1@Tp71TrPMXfCR@UdgF@fG4gtkXtqadiFs91cjoJCi7dUTBlB5YsptKxJbAMvakvioT0lNOjqRdgz@cdqMApVfCZqGaNBzaNwElc8pC444F6HOSIJTscCWpQifiG@nyipG50Z@@dhOakF6wf8QXudOrAzVmJhcQOMQj3X@CLYdDt3CZZw8UpO9cwTf5bQGTlGD1RrlhxxOvkxbEcLDc/foE4Q5N41XKqfg7edUy@Vy1fxKAhUcHMqyqu8prQNCkphlU3@QJh/H3yHV4/NR6RbGs54gDbOo8iO93qhi/vOSDEfGawJuFSlJJHrrjvZTFG4xczExrA3svtsryXi3mDpw6mKm40x50FCTwYOqaE9C29pOnjDgWTs0gG4lHAC0YGYUia8pytCLa/I93A79s7FqiseAkCO/@6YSAdvQOLQ2jwkaqCudsy9aiAvIa@DuzaFVt1heOwjAQUuhPf7bXD1l1RXYMKaKwXV08MWntuWErJhJVUh3hI79oPnWqkKrJ/vtL1nOPdnLd5ouO25@Y4dmBzNS1MuNOLbmKm8K7j7YS7ETroGY83Pqie9mLvoHfcfTYO03Vl8V0Q58eU3dPDiXjXDRp38@XRE4dOeKO1DATwNUN@xpEPfkI/CMeVXsdJ4JnphVKiiU02RftN0MWT@szT3zGjF3rHcmCBVp@Nr7lEzhQkGPAFJ7q6hRO0VszlSeklgtFik3C7N@jzxXd06miJbLqAcwcfsubrBgkA8RGXrz24/0DMwQPOudFx7G50nBNPtkY6aLK28CHdDL1DYZMopdFtIm2ml9dXk@5Zzxjoyfigjq/JMaSkYOZsD4rEeTuKJZkQKAnajiycpXqevC9m9zlgkgTqEYO8NO9LcLMJHDlSCwgxy1Pg5WeAwrcq5il2nctnVxDIuawqIFnp3Rffi84qcIbi0UzTwuT4FygyyRFSiRLdBIoX6m2LaHMOHqX1wg21HQyXEWfMcuEpT2QK4nJlUwyazP/2KRJI3DKfNZuM41iAFgsQteUxBpZpWDF6qnFkCPmU0SfxVEb/xClcclyWnPDtwGnmb1VkZA4ya476gsE/mf1cdSbPag2ch5HpMqgqx/zZjh2VdVms6LhNItAusNESrPKYxnLttPkPJzTXLgMVtBQl8nMApvec@XtIBCdjqCbNaHUgSHCKcCzcRUTPEojgU0uUSLSSl9g15XG3SiFzWW@7oYiiw43UGx75jqALzFhLCZSRBgM/CrkWcAS7rr6jATu//lZZRPElC5UNQifQVuxul@LxVugS8xt4AawSJXQDxPCOjTojZyJ5B3mU39HHlYEf9OTig1Hq2/agGy7DZ13XasC54l9No4QGKSTeoYAejhJU9wZxCeTBLOPj4AG0RVnqFgzEDgeawohlnkbupV9Z8l3U7dwEnsgXIvf2LTXEkX/kI2SE3QRxpbzyyPdOliszqfkMVyLAz6aHmlOSbxxJly0wrSSYzFHZJpfDYl4SLJkal7tOuNvDYye95zn6uA2dxLa599jtNHfzBSUsSr/4xS9gSu2ByGTl3d6mZdQJYoty8U4wZ5Rkau0qbn@hkNgER4OyLq68T@9vH1PwFsj1251x@hDtNHdpl5nTuMpImMC9qDUiafQSe/eKbiEK08hW2sfulpnMhTvXFEeMl1EMi8RT4r4K0mm9nrbKtxZoxgL8Xlqo4G@zPCOc3hybgynx1zasRVoLtYyuto1ZYbRdX3P38ELO/gDzeLPJEkThQ1A6Qptzx6RdqW9ShC2pBtM6IqNNz7b0Rd3imx0wjHzd3nbwIgw8ijsYx6xNe78ZNveDptPcbbYLHAwj3ZLr4M6c9@6RMsnxy2IHH93jmdoY8AXU3mMFdwa40oPdxEpCrUqcM2BegvhOUGKhzGxTrbHRS6nQpGZJFT1W91FK8plF@lYre18YTOLRqLw43Q/GTQ@uo5p00goiyELoBMYw6ahz0S2TncfwB9Pa6zlGaHs/8iH3rV2rP4Xd2lDrmJlKU1woR8dAPRhVHur0JiGt4BWwFY0o5nACvgrH81SHw@Jbg@5DGczvy0mpHfSiXB8JUSiuvaHQq@9Edo8h7zNzLuhWP2NN1XGM7WaoWChvIjet4LYI1AeITp40cvKkUWJLU1QTPfM1xyyonyNayc8a/nH82Od5/gahtPN98lmIFj50uFlo@ZUlfWrxGo5jmNxDehwYVebQlV1uc685aA7awUQhFsU1U8ghhTCXAgBVUsYds6/cvHsfIYunLt3ot7BUegUd4SX53Fly86DETF/TlTTu4kXTqopG/Ifaq1HUp6eH2quvSOs8ucmjtPlW5rrCO/1q9csL0If4/jbZkLFXIR3QiO8RzLuuzdzYq0SO6MZA1HkCSzOm3Kd74/XXFl595Te/@c3V5pIuejmoxHTzeUT9cZMtJeUK47tyFQlZWWZtV4Zf6v7IRTK@X0@Zh18pg8LNL7c9XTpH6wYu66RSmDkymPeQ4wzJhes1XhQB4OSJzHW@XomC1xZEqNqSPkpsV2/j@rs24SCTvNrQWYIWa2mKEfH3FitolJqCkm7sOuLKCZZdbkcGLtldDF1@jKUUwCLg2e3ICnxDdlEVuVqIpGbHdIaWcAqTJdxO/ntB5PEKnTiEddN3OXNOgKe/S@hkpCNOGWOK@pJchFAWeNNki@drxa34diNazuDrMEp8cvS1kstJjLxGOcwqfM5sKA9NYgbxAApYFDYW39HznF3HRoCgWXAcbo/odG1KNcwwLFS5jz@iszfDEBGxmCIujmdFucRxYwemeSDuxUqFiWmRTS1mIWxASzagenMcmAsS6tnxV1OHn3XsnG2s/JzwHRibg9OmxFKcI4y@yG06nsRmoWUIzWqr3WxN0VhLeBQunD37d4xzr@LtO5vo4vhleRHPgm0x5x5imsTNEp3tyF4YrYptCoEmJLQygHwHGga8Hh3bBaGOqJezkwxSatKeUpWzviB1RsOQSkLqpXKCuLb6DnRvWF/gJGzfNzjy/HvTGDqUse77kQgH/940I0UnB17iZBmJMM5u5peVjEYFprGJFrAcyyfDLrB/FhjCpEKlaGMF3ZvQsCFqmudCIFLIU@OX5x@pWKOUfF5mWclhdfxRBtAUirlwPEB8R28Ogl22m7Wb7S6fPTndvZ/Ai2gBXck1bEv3HvZFVPzY8px7IkoVTpSsaq1l6E924XntIqeRwORrmHGVTzRzfX6YpwT@luIIM8mrOFEJBqadwwqKDVb@xIM5SXGPwJMjL7Tg/5Rxp0MAGvZufN4Dz0qBzMlZkirGSvpYCMchOh@OEpBZMuqKkmG@j2FKuDmtoDL@UvokCs/saP8lmOjcXKIM9dTDljtmU1jl1VHDjV561KIUvx68lIPxsw/WhJue/qpjNg2lQCQ4fjgti8cBhb3t/8/vY/idZM9PllRTc/0dO5hIS9Rgnv2QGLSM/u072yN5Lmz3pk2wQUETWP9qeZ4VZNZ17F6@g52fVH98utN8mwzox1GCobj5cXfAMcLRuvZSONf/ujjzAXWv9f6U8uOqRA/vxNSLYPIx15Rgx1IgakWaG/CA7733H3ELqR7L9iKM3EDG5EdbMNSfOT0Wd51yMImswF9XoCYnykr3iHTF6cnEDWcRkgDZwnk71G5PK7iHyngr2@DEtj9OwkX20NQET5CA8/ykSsj0Cby9yABgIHK/IgoZaMcU@xFhyzStqHtiW5IDyOJrGlJvRtlHCa2fWzxncwrOXJ3UcwnlPGBgUCQUUXtSJUO@Lyqf6rEgy@h2WDS31CzBU0kYXjjSCaqkED46rbxSVmAu5suPSPhnDwso1wS7iTVbzSBagdfFde98O4E04Ik7HRZL5XK5NG6VYIhoWGmdnfwrbs7lbcmBWQnEuVcil1GLDLJYgJ6aSyAvN/WS/J7Y6uPd6S0QMIGcEv/EaGLsvEQA5@nZybcvTvVFJW8xFaMEt8pt9osK8GBocLyjtDjBRj0OgqSHtFUfvTgtMOu@5niR6W6iQud2KOAOEwqii8CF@q/ncnJVDfGMdZQ65y3cKEoToDgbTlgCI/8c8RKYiE/RRHRv@jCNComyaseK9JCo/Hk2Sp2w2xJ5EIcwwY9ON0U6Nbz@G7/RLeBmBaiPF6pxzqiUkGcnj5vkfhxMm8gOxxIPXPh4AG9aqYos5iqgzAiLl01vmouZ2KLw7vrtYe3CBViivsbOsae7zIb4HXX3k09x8Xo@Qj9vmRLR0st6KlMkRobpwMpEBozPQloMeU6I19gIFVmMC5yPtoBZ7YKHyP328zsraAnE45jalerZs38zxXPoUj557tr@w07vwDvfYADQV8pYdfnNO2UJok4nSmMHA50L/9MGZAwHDaXEEENCpF7Y5JSYODoLC7CYLC3p5OrxZx6mMVSvJ6ku5MdC33ekjz/6MMxu23tu93EDiDh35aL2tue2gT6lJfL/X6hA6SU9J0QIYaGDFBNSpBhv4raquY65j97w1jFN3R3Xc4Lmfd/da95EFwJM8AqrzvVurz3FJWXx9Tlvry@/ttqIvscvImfJJDJ6XyaDwUN3RKukpyrhBxTpO1Bxl/KnBH2Zii9RKMAgXLuLrhzqrUAFuLBzvvOYXKYTiwZluaPczbiWJ6HFQO6trr99535hVxeyHVvK9iKJM4zi0hRgpsY6AS8RC4sDTUkukXsj4WBWWEKIQhlGwBqTxJGom@GtRF3Ky0cfjr4uL8Kk0XRZEbuI@gIsmOnpIpRbqQfV@Mu99dtmOTWV5ExS5hOeYx19ySoV3WpfFgcxgBCGUGcQRjUGkUXkLJjgL06JaPghQxiipxbZKjKSDCPBtPVBC5Nz4Mzj/Hk7@0236Tv9bnPbPbyDv@5NKVEVqwhW5YubN4Yjw7z26/KFzc3/9ssPt8StgJubVc5BAwKi7eCVMs6Oc0ieTtF5VoD8sxkDvEeH@NDvX8H/m5sqJNV3GybzJtp8XtV@FdWOwtXkRlGNkxO3Z5druSky8Wdnn5wo/pE3Ui9OZbJAhCLujXzxp7qINd23fRcdXgIyuGwPPNJkA8pdZmlBzw/hF/sVcE6oPTts70LxlrONfjDwML1bN6jBjZ39LeyzgbRAHvj8xSliQKmBP4@KmKafTGwrOhbgQLvhgPRquh0tk0@AzgQRMdzgEmgO1Y@eZQ9bsB5NU/Q1SdeFFa24qoTPnUj3GBmI32w0a1um0m9@Vt/Cs0t/QkrbhGcAfuG0Q0QPZRczk9jTCAcV@a7BJiUKqdAaWqIoOfbdcALSBTGdRQO@YQJ8zOpFNaiEEgEGJTZkXMJG7Oy2tTUzPvX@jV77uk0XRei7YdhvVCoHBwflg7mgvdvrgdgACYvehgH@eo9aLttBX58MlS8pQLgV@EZ3blF8aYVfLL95O6igzfNimdzQJgCE4nfw4jlUVWZgGNBVZ0bKjTd546BeTTKjBpsoZNIa2FvNsKJQFhxTAbBG@U9/DqgESIFcTwUNNe2xzdicheqjCB6ndsXLlITxxEYutWXsgQA7AT2bMEKWJs6bMUTYRXwt3zdmmRqkBQSZTPDo/YhHqUI55sAkj0Lzfg8vQaGcj8zZs5TOvg8YgTzy3UPceuPlS3kMjM@BjZ0uZzDYQJdEx78HGrH8zM@RpCtQ6nYn4C9QBD7jxdtbfH0JAhI/s6mGUYbjxZRdUEpEjE3cn6htqohtKFn5qISCE5R4BaHyI81H1T4uwmBmtVv81k6CUbswq@FVw/GdT7dviBy2C2GHEtsRfrc77/n19lxpKarPvdYy9eE5w1gI/WT93kFd1Ge2A6UHJl3QaPBgvizVViZS7dZkqt2agmp3fyLV7v5Eqq3YfXkvEca8iW94mQ1dpuT4lEOSXbPCXl96kvJMWJDlVeDiGcDPubDhBl8fV9Wi6x7yrqUSxI@PhlK3SUWkj2xveQXGgVDIXgAjJmxc4GYCS@6nyKOYE61caAcqDhrMCUQmyfKS4JL@rcT0qGDIO/yA/tGzTORK7ezpH1HLyavFlywXVjdo2kVTSJkpyoxQGT@mtSnu0ks4Tr08uCxRxfIgnPSxqSbO12YbVIPmbsenLziRm7hfo09uJ2gG7gcOfaHwT6yCT7EIVcAP8gGXELNg3MipFkNB3BvxYIsnhuEzn//4RUWaLWgkTQtRpisP@ao/fir@yiAb7hAaXPHPM1DKv8Egl4iE8p7xiJexj/AHO6KczKo50AHC069WEt1LgtATYkG33I6lx1JBtyLTvZxCJto/RIGlvPwi6lndguiTGrTAgySwJ/oLZzR1e4BDiEW4OlEvpZ4rPJSyncYtDHXRK4O6RU5tut/mrebntDk26VYH/Pgttjk29keNPIqYOadx2SnqxMl3w3QMhZr1iw4/jr7c3hM5c9CXLRd4Bh0x@JT8RHQZ@hW1bw4NPdwlj0/T8dpaNI5sdYiY7VOFA2mbQrMlZ0gk0ZXJmlMrIjlRHB7rlsGnOQqls1xR1DscsJBCQ6gP1Ap2zI86xmd4I3Ijx4KTOFKKAZFpVU7F2SxOQk6ICTaBUyXY87Fq3MQ5WBVVczkxquaFc/OuFM45uJyXc1@cJhg3B3IGEyGsiG1F96GPUePmUAcFikYXndgV@cMUWKiEnSVdZeDP/toMLFq@AGSXoz5Fh4mTKdZpGk7Ggnkx7bHPnRDBFvK8pRSPt1TXl9dX1cCaxNIqXALE8CXSu/3VcjBOyL84Re7F/LyLeWdjSN8oPoJZi@IkFio0vs/5@peEV7wpoijiLStsQOOQ5f8QFryZOa3@fwA "APL (Dyalog Unicode) – Try It Online")
Explanation:
`(`…`).Render` Render the following HTML element:
 `⎕NEW _.Table (`…`)` a new Table with the following parameters:
  `(`…`) ⍬ 1` the following content, no special styling, 1 header row:
   `⎕⍴0` evaluated input reshapes zero (i.e. an m-row, n-column matrix of zeros)
[Answer]
# [Python 2](https://docs.python.org/2/), 57 bytes
```
lambda m,n:'<table><tr>'+'<th>A'*n+('<tr>'+'<td>A'*n)*~-m
```
[Try it online!](https://tio.run/##K6gsycjPM/qfZhvzPycxNyklUSFXJ89K3aYkMSkn1c6mpMhOXRvIy7BzVNfK09ZQh4ukgEU0tep0c/8XFGXmlSikaRjpGGv@BwA "Python 2 – Try It Online") Assumes `m` isn't zero.
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), 31 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
<ŗ>
table⁸ｏ╶［tr⁸⁶｛¹１≡╵dh＠t×⁸；｝］
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JTNDJXUwMTU3JTNFJTBBdGFibGUldTIwNzgldUZGNEYldTI1NzYldUZGM0J0ciV1MjA3OCV1MjA3NiV1RkY1QiVCOSV1RkYxMSV1MjI2MSV1MjU3NWRoJXVGRjIwdCVENyV1MjA3OCV1RkYxQiV1RkY1RCV1RkYzRA__,i=NCUwQTM_,v=2) or
[Try it visualized!](https://dzaima.github.io/Canvas/?u=JTNDJXUwMTU3JTNFJTBBdGFibGUldTIwNzgldUZGNEYldTI1NzYldUZGM0J0ciV1MjA3OCV1MjA3NiV1RkY1QiVCOSV1RkYxMSV1MjI2MSV1MjU3NWRoJXVGRjIwdCVENyV1MjA3OCV1RkYxQiV1RkY1RCV1RkYzRCV1RkY1MCUyOHQlM0QlMjQlMjglMjJ0YWJsZSUyMiUyOSU1QjElNUQlMjklM0Z0LnJlbW92ZSUyOCUyOSUzQTAlM0JidXR0b25QYW5lbC5pbm5lckhUTUwrJTNEb3V0cHV0JXVGRjAzJXUyNTEw,i=NiUwQTEw,v=2)
After fixing 2 bugs (ಠ\_ಠ) in the interpreter, [30 bytes](https://dzaima.github.io/Canvas/?u=JTNDJXUwMTU3JTNFJTBBdGFibGUldTIwNzgldUZGNEYldTI1NzYldUZGM0J0ciV1MjA3OCV1MjA3NiV1RkY1QiVCOSV1MjU3NyV1MjAzQ2RoJXVGRjIwdCVENyV1MjA3OCV1RkYxQiV1RkY1RCV1RkYzRA__,i=NCUwQTM_,v=2) works too
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 30 bytes
```
’<…È>’sF"<tr>"„hdNĀè"<tÿ>A"I×J
```
[Try it online!](https://tio.run/##MzBNTDJM/f//UcNMm0cNyw532AFZxW5KNiVFdkqPGuZlpPgdaTi8Asg/vN/OUcnz8HSv//@NuIwB "05AB1E – Try It Online")
**Explanation**
```
’<…È>’                           # push "<table>"
      sF                         # no-of-rows times do:
        "<tr>"                   # push "<tr>"
              „hd                # push "hd"
                 NĀ              # push the iteration counter truthified
                   è             # index into the 2-char string with this
                    "<tÿ>A"      # insert the result into the string "<tÿ>A" instead of ÿ
                           I×    # repeat this string no-of-columns times
                             J   # join the stack to a single string
```
[Answer]
# JavaScript, 65 bytes
```
f=(m,n)=>m?f(--m,n)+'<tr>'+`<t${m?'d':'h'}>x`.repeat(n):'<table>'
document.write(f(4,3));
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 28 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
üÉ$♠═?S┼╪├8°‼←sí☼←T≡┴╜ô‼\↑0ⁿ
```
[Run and debug it](https://staxlang.xyz/#p=81902406cd3f53c5d8c338f8131b73a10f1b54f0c1bd93135c1830fc&i=2+3&a=1)
Unpacked, ungolfed, and commented, it looks like this.
```
"<table>"P  print "table"
"<th>A"*    "<th>A" repeated specified number of times
,D          repeat the rest of the program specified number of times
  "<tr>"p   print "<tr>" with no newline
  Q         print top of stack without popping
  .hd|t     replace "h" with "d"
```
[Run this one](https://staxlang.xyz/#c=%22%3Ctable%3E%22P%09print+%22table%22%0A%22%3Cth%3EA%22*++%09%22%3Cth%3EA%22+repeated+specified+number+of+times%0A,D++++++++%09repeat+the+rest+of+the+program+specified+number+of+times%0A++%22%3Ctr%3E%22p+%09print+%22%3Ctr%3E%22+with+no+newline%0A++Q+++++++%09print+top+of+stack+without+popping%0A++.hd%7Ct+++%09replace+%22h%22+with+%22d%22&i=2+3&a=1)
[Answer]
# Java 10, ~~139~~ ~~133~~ 102 bytes
```
m->n->{var r="<table>";for(int j=0,i;j++<m;)for(r+="<tr>",i=n;i-->0;r+=j<2?"<th>A":"<td>B");return r;}
```
[Try it online.](https://tio.run/##jY@xasMwEIb3PMWhycKWSFPoUNkK6VDo0Clj6aDYcipVlo18NoTgZ3fl1mRN4UA//30H@qwaFbPV91w61ffwroy/bgB6VGhKsHHLBzSO14Mv0bSev64hf/Oozzpk/4OOGIw/Swk1FDA3THomr6MKEAqSozo5LYmo25AYj2CLbWaETdO8EXQpQ7pQQZLMFF4YxuRWxM7mu33sv@SBPMe3ki@EiqBxCB6CmGYRTeJ0w8lFmdVpbE0FTfRM/v708QmKLs4Ax0uPuuHtgLyLK3Q@qbnqOndJdnQNj5SKe/ATvV3dhx/oLfzC02aafwA)
**Explanation:**
```
n->m->{                  // Method with two integer parameters and String return-type
  var r="<table>";       //  Result-String, starting at "<table>"
  for(int j=0,i;j++<m;)  //  Loop `j` over the rows in the range [0, `m`)
    for(r+="<tr>",       //   Append "<tr>" to the result
        i=n;i-->0;       //   Inner loop `i` over the columns in the range [`n`, 0)
      r+=j<2?            //    If `j` is 1 (first iteration):
          "<th>A"        //     Append "<th>A" to the result
         :               //    Else:
          "<td>B");      //     Append "<td>B" to the result
  return r;}             //  Return the result
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~42~~ 38 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
-4 thanks to ngn.
Full program. Prompts stdin for the two-element list [m,n] and prints unclosed tags to stdout.
```
'<table>',∊'<tr>',⍤1{'d'}@3⍀⎕⍴⊂'<th>A'
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97b@6TUliUk6qnbrOo44uIKcIxOpdYlitnqJe62D8qLfhUd/UR71bHnU1AWUz7BzVQfr@KwBBGpexggkXhGWkYAQA "APL (Dyalog Unicode) – Try It Online")
`⊂'<th>A'` enclose this string to treat it as a whole
`⎕⍴` prompt for dimensions and cyclically **r**eshape the single cell to a matrix of that size
`…⍀` cumulatively insert the following function between each vertical pair of cells:
 `{'d'}@3` ignore upper cell; place `d` at 3rd position in bottom cell
`'<tr>',⍤1` prepend this string each row
`∊` **ϵ**nlist (flatten)
`'<table>',` prepend this string
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~107~~ ~~99~~ ~~98~~ 97 bytes
```
i;f(x,y){char s[]="<th>A";for(puts("<table><tr>");x--;s[2]=96+puts("<tr>"))for(i=y;i--;)puts(s);}
```
[Try it online!](https://tio.run/##RY3NCsIwEITvfYrQU1Yb0AqCbBvwOUoOMfQnoKkkqbSUPntMA@KcZuabZRXrlQpBY0fnYoFVDdIS14g6r/zA7zl2o6XvyTsaC/l4trzylueAM2PomlLUt@vxx3cA@4GuF9RxAIk4wC1o48lLakN3I22vCpJ@HaL/NALImpGojko/aprKs4Din0oBgGljWz9ZQ06YbSGU4fIF "C (gcc) – Try It Online")
-8 bytes thanks to potato
-2 bytes thanks to ceilingcat
The `s` array has to be declared as an array not a pointer otherwise it won't be editable (we set the first h to a d). Most browsers don't even care if your closing tag is correct, so we just close all tags with `</t>`.
[Answer]
# [R](https://www.r-project.org/), 73 bytes
```
function(n,m)cat("<table><tr>","<th>A"<m,c("<tr>","<td>A"<m)<n-1)
"<"=rep
```
[Try it online!](https://tio.run/##K/qfZqP7P600L7kkMz9PI08nVzM5sURDyaYkMSkn1c6mpMhOSQfIy7BzVLLJ1UkGyUCFUsBCmjZ5uoaaXEo2SrZFqQX/0zSMdIw1/wMA "R – Try It Online")
Saved 7 bytes with a dirty hack - replace "rep" by "<".
[Answer]
# [PowerShell Core](https://github.com/PowerShell/PowerShell), ~~72~~ 68 bytes
```
Function F($m,$n){'<table><tr>'+'<th>A'*$n+('<tr>'+'<td>A'*$n)*--$m}
```
[Try it online!](https://tio.run/##rVJLCsIwEF0npwglkH7sws9C7Afc9AQeQG0HFZq0thGFkrPXxKJWpKDQRV5mhsy8l7yUxRWq@gh57qdFBW1yEak8FYJsoJa4QRhRHs0CQkU0D0wGtxJSCRmJCAvlbp9DHMpKr2O87oMpZSZ4AtPNUg/VjQmhXE8MMLIMzUkcCI9ow9WECL0LtdpKy7O74z6cyYvVwZ2i6d@KRqVfPOhnv9J/vsVwNp7Gnm3L4A/XBuHLzkEY5xIIq/dfTGzKJ1Q4TV8781hnrEuFZ7NXKetKjuv7lKvWELd3 "PowerShell Core – Try It Online")
Here are my test cases and expected outputs (C.f., TIO)
* m=2; n=3 `<table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A`
* m=1; n=3 `<table><tr><th>A<th>A<th>A`
* m=4; n=2 `<table><tr><th>A<th>A<tr><td>A<td>A<tr><td>A<td>A<tr><td>A<td>A`
* m=2; n=8 `<table><tr><th>A<th>A<th>A<th>A<th>A<th>A<th>A<th>A<tr><td>A<td>A<td>A<td>A<td>A<td>A<td>A<td>A`
Thanks, @[mazzy](https://codegolf.stackexchange.com/users/80745/mazzy), for the -4 bytes!
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), ~~24 23.5 22~~ 21.5 bytes
```
;~"able"::"<t"$">".`,_:@"r"^_:@?$"d" "h"
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708LzMpKSe1eMGCpaUlaboWNzWs65QSgSJKVlZKNiVKKkp2SnoJOvFWDkpFSnFAyl5FKUVJQSlDCaIeqm1ltJKFko6SqVIsVAAA)
Takes arguments in the order `cols rows`. Outputs something like this (for `8 5`):
```
<table><tr><th>0<th>0<th>0<th>0<th>0<th>0<th>0<th>0
<tr><td>1<td>1<td>1<td>1<td>1<td>1<td>1<td>1
<tr><td>2<td>2<td>2<td>2<td>2<td>2<td>2<td>2
<tr><td>3<td>3<td>3<td>3<td>3<td>3<td>3<td>3
<tr><td>4<td>4<td>4<td>4<td>4<td>4<td>4<td>4
```
## Explanation
```
;~     Define function f(str)
"able"  and call it with str = "able":
:       join
:        join
"<t"      "<t"
$         str
">"      ">"
.      Map
`,      0...
_        number of rows
:       join
@        f
"r"       "r"
^        repeat
_         number of columns
:         join
@          f
?           if
$            row index is positive
"d"          then "d"
"h"          else "h"
           row index
```
[Answer]
# [Haskell](https://www.haskell.org/), ~~109~~ ~~107~~ 103 bytes
```
n!i="<t"++n++'>':i++"</t"++n++">"
r#c="able"!("r"!([1..c]*>"h"!"H")++([2..r]*>("r"!([1..c]*>"d"!"A"))))
```
So many parentheses… Thanks to @nimi for two bytes (and a loss of genericity)!
[Try it online!](https://tio.run/##bY@xDoJADIZ3n@IoA5wXMGhcDJxhY3BzNA6nnHIRDnLUwafHosZg4tI0zde/XyvV33RdD257ziBFdaq1TNFJECI8JHF8Ps4lzStZpAuqwIUA6j7AMo4dASH8WSllTmA5XeGf9nUFZlHEkmTNTg/UPbu0jinWo1PmWiEzTVfrRltUaFo7WM@MenTCChHIYGPeSe8BUJjz6YExGLwQHJWvSgUeFKPFxPcHKAnISY7zoVHGZt0d9@h2loUrf8mHJw "Haskell – Try It Online")
Without end tags the straight implementation wins at 87 bytes ([Try it online](https://tio.run/##y0gszk7Nyfn/v8g@2VbJpiQxKSfVzqakyE5JW1sj2lBPLzlWyw4onmHnoaQJEjLS0ysCCmkoYVGUYueopKkJVKZkow8xSel/bmJmnq1CQWlJcEmRT56ChrG9keZ/AA "Haskell – Try It Online")):
```
r?c="<table><tr>"++([1..c]*>"<th>H")++([2..r]*>("<tr>"++([1..c]*>"<td>A")))++"</table>"
```
[Answer]
# APL+WIN, ~~68 63~~ 56 bytes
12 bytes in total saved thanks to Adám
Prompts for number of rows followed by number of columns and outputs non-closure option:
```
t←⊂'<tr>'⋄'<table>'t(n⍴⊂'<th>A'),,t,((⎕-1),n←⎕)⍴⊂'<td>A'
```
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~56~~ 54 bytes
```
(.+) (.+)
<table>$1*$(<tr>$2*$(<td>@
T`\d`\h`^.*?r.*?r
```
[Try it online!](https://tio.run/##K0otycxLNPz/X0NPW1MBRHDZlCQm5aTaqRhqqWjYlBTZqRiBGSl2DlwhCTEpCTEZCXF6WvZFIPz/v5GCMQA "Retina – Try It Online") Edit: Saved 2 bytes thanks to @CowsQuack. Explanation: The first stage uses Retina 1's string multiplication first to generate the appropriate number of cells, then to generate the appropriate number of rows. The second stage then changes the first row of `td`s into `th`s.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 33 bytes
```
<table><tr>×<th>AηＦ⊖θ«<tr>×<td>Aη
```
[Try it online!](https://tio.run/##S85ILErOT8z5/9@mJDEpJ9XOpqTI7vB0m5IMO8dz29/vWfaoa9q5HYdWw4RTQML//0cb6RjH/tdNBAA "Charcoal – Try It Online")
### Explanation
```
<table><tr>                         Print "<table><tr>"
           ×<th>Aη                  Print "<th>A" * second input
                  Ｆ⊖θ«            For i in (implicit) range over first input
                        <tr>        Print("<tr>")
                            ×<td>Aη Print("<td>A") * second input
```
[Answer]
# K, 58 bytes
K version is whatever is included in `KDB+ 3.5 2017.11.30`.
Port of the Python answer above. Ends up being 1 byte longer due to having to enlist and flatten multiple times.
```
{,/"<table><tr>",(y#,"<th>A"),(x-1)#,("<tr>",/y#,"<td>A")}
```
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~65~~ 54 bytes
*-11 bytes thanks to @msh2108's reminder*
```
/ /;$_="<table><tr>"."<th>A"x$'.('<tr>'.'<td>B'x$')x$`
```
[Try it online!](https://tio.run/##K0gtyjH9/19fQd9aJd5WyaYkMSkn1c6mpMhOSQ/Iy7BzVKpQUdfTUAcJqesBqRQ7J3WgkGaFSsL//6YKxv/yC0oy8/OK/@sW/Nf1NdUzMDQAAA "Perl 5 – Try It Online")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), 130 bytes
```
m=>n=>{var r="<table>";for(int i=0;i++<m;)r+="<tr>"+string.Concat(System.Linq.Enumerable.Repeat(i<2?"<th>H":"<td>D",n));return r;}
```
[Try it online!](https://tio.run/##XY7BSgMxEIbP2acIOSVsu0i9mU160BYPFkQPnmOarQPNRCfZgpR99m2KguBpmPnn@/h9XvpEYfZHlzN/pnQgF88Ny8UV8PyUYM93DlCqemSv37mE2G1H9D1gWfzfcyHAg7V84GaOxqKx55MjTkb0xb0fgxV6SCTrLwdzo6Ft@6gVtdecrGh/BN19Qu@K/NU/AX51GxxjoKujewmfoabQr9YV@7CP4q7OvX0QC1RKUygjISc9zYzpv9ZVmlPF3whKqM4gB7lS8rYiDZuaab4A "C# (.NET Core) – Try It Online")
[Answer]
# [Carrot](https://github.com/kritixilithos/Carrot), ~~77~~ 51 bytes
```
<th>A^*$v<tr>vl+(^h)*($^F- 1)A"h"S"d"h+(^l)v<table>
```
(While working on this, I discovered a bug with `h` not working and fixed it)
Golfed some bytes by shortening the html as well as using "split, join" instead of "replace"
[Try it online!](https://tio.run/##S04sKsov@f/fpiTDzjFOS6XMpqTIrixHWyMuQ1NLQyXOTVfBUNNRKUMpWClFKQMonKMJVJKYlJNq9/@/sYIRAA "Carrot – Try It Online"), use the command-line option `-d` to see the AST (Note: this uses the new node interpreter, so the older version on the website cannot run this.)
This program takes the input 0-indexed and in reversed order, because of Carrot's weird nature, thus `3 2` printing a 3×4 table.
Run the program like so, `./carrot -f prog.carrot input.txt`
Basically creates the header row, then the data rows on another cell of the garden (2D tape), and concatenates them together.
---
Carrot works on a 2D tape, called a garden. Each cell on the garden is made up of three stack modes, string, float, array. There is a value for each mode, called a "stack" (note: misnomer). These stacks begin empty. When a cell is at a particular mode, the following commands will affect the stack that corresponds to this mode, for example in float mode, the operations will affect the stack float. And of course, there are commands for switching between modes. The modes are important because each operator can be overloaded for each mode and each argument type.
In addition, there are two additional modes (these only affect the commands, not the stack directly), normal mode and caret mode. Normal mode works normally, where there are operators taking in arguments and affecting the stack directly. In caret mode, (almost) every character is interpreted literally as a string, and is later prepended/appended accordingly to the stack. Caret mode is started/ended with carets (append) or down-carets (prepend).
Carrot begins in a cell on the garden, in stack-string mode, and in caret mode.
---
Beginning in caret-mode, the string `<th>A` is added to the initially empty stack-string. Then follows the `*` command that duplicates it `$`, the input, times. Then `<tr>` is prepended to the stack-string by the usage of the down-caret `v`. This creates the header row of the table.
To create the data rows, we duplicate the header to another cell. `l` moves the IP to the right empty cell, and `+` appends `(^h)` the string in the cell to the left (essentially copying it to the cell on the right). `()` starts a subshell, a new Carrot program with almost the same tape, and `^` exits out of caret-mode so that we can `h` get the string in the left cell. This is then `*` duplicated by `($^F- 1)`, the next input minus 1, times.
Still in the right cell, `A` sets the array of this cell to its stack- tring split by `"h"`. `S` joins the stack array by `"d"` and sets the stack string to this value. `A"h"S"d"` really just replaces `h`s with `d`s to form the data rows. Now `h` we move to the left starting cell.
Now we append the stack string of the cell to the right to this cell using `+(^l)`. All that's remaining is to add the `<table>` tag, so we do this by `v` prepending it.
[Answer]
# Powershell, 63 bytes
```
$m,$n=$args;$t='h';'<table>';1..$m|%{'<tr>'+"<t$t>A"*$n;$t='d'}
```
save it as `new-mntable.ps1`. Test script:
```
.\new-mntable.ps1 2 3
.\new-mntable.ps1 1 3
.\new-mntable.ps1 4 2
.\new-mntable.ps1 2 8
```
output (extra spaces are optional):
```
<table>
<tr><th>A<th>A<th>A
<tr><td>A<td>A<td>A
<table>
<tr><th>A<th>A<th>A
<table>
<tr><th>A<th>A
<tr><td>A<td>A
<tr><td>A<td>A
<tr><td>A<td>A
<table>
<tr><th>A<th>A<th>A<th>A<th>A<th>A<th>A<th>A
<tr><td>A<td>A<td>A<td>A<td>A<td>A<td>A<td>A
```
---
# Powershell, 65 bytes, `-replace`
```
'<table>h'+'d'*--$args[0]-replace'h|d',('<tr>'+'<t$0>A'*$args[1])
```
save it as `new-mntable.ps1`. Test script:
```
.\new-mntable.ps1 2 3
.\new-mntable.ps1 1 3
.\new-mntable.ps1 4 2
.\new-mntable.ps1 2 8
```
output:
```
<table><tr><th>A<th>A<th>A<tr><td>A<td>A<td>A
<table><tr><th>A<th>A<th>A
<table><tr><th>A<th>A<tr><td>A<td>A<tr><td>A<td>A<tr><td>A<td>A
<table><tr><th>A<th>A<th>A<th>A<th>A<th>A<th>A<th>A<tr><td>A<td>A<td>A<td>A<td>A<td>A<td>A<td>A
```
How it work:
1. `'<table>h'+'d'*--$args[0]` - create a string like `<table>hddd...`
2. `'h|d'`- search `h` or `d` chars in the string for replacing
3. `'<tr>'+'<t$0>A'*$args[1]` - replace each char with string like `<tr><t$0>A<t$0>A...`
4. where `$0` is a captured `group[0]` - the char in the `-replace`.
---
# Powershell, 65 bytes, `scriptblock`
```
$m,$n=$args;'<table>';&($r={'<tr>'+"<t$args>A"*$n})h;(&$r d)*--$m
```
save it as `new-mntable.ps1`. Test script:
```
.\new-mntable.ps1 2 3
.\new-mntable.ps1 1 3
.\new-mntable.ps1 4 2
.\new-mntable.ps1 2 8
```
output:
```
<table>
<tr><th>A<th>A<th>A
<tr><td>A<td>A<td>A
<table>
<tr><th>A<th>A<th>A
<table>
<tr><th>A<th>A
<tr><td>A<td>A<tr><td>A<td>A<tr><td>A<td>A
<table>
<tr><th>A<th>A<th>A<th>A<th>A<th>A<th>A<th>A
<tr><td>A<td>A<td>A<td>A<td>A<td>A<td>A<td>A
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 34 bytes
```
`<∨ø>`?(`<tr>`‛hdn1>i`<t%>A`$%⁰*Wṅ
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCJgPOKIqMO4PmA/KGA8dHI+YOKAm2hkbjE+aWA8dCU+QWAkJeKBsCpX4bmFIiwiIiwiMlxuMyJd)
Port of Emigna's 05AB1E answer.
#### Explanation
```
`<∨ø>`         # Push "<table>"
      ?(       # Input number of times:
        `<tr>` #  Push "<tr>
‛hd            #  Push "hd"
   n1>         #  Is the loop variable
               #  greater than 1?
      i        #  Index into "hd"
       `<t%>A` #  Push "<t%>A"
$%             #  Replace "%" with
               #  either "h" or "d"
   ⁰*          #  Multiply this string
               #  by the second input
     Wṅ        #  Join the stack into a string
               #  Implicit output
```
[Answer]
# [Go](https://go.dev), ~~130~~ 123 bytes
```
func f(r,c int)(s string){for d,i:="<th>A",0;i<r;i++{if i>0{d="<td>A"}
s+="<tr>"
for j:=0;j<c;j++{s+=d}}
return"<table>"+s}
```
[Attempt This Online!](https://ato.pxeger.com/run?1=TY5NDoIwEEb3PUXTVRuqIRoT5aeJN_AKCBQHoZBSVk1P4oaYeAiP4m0sSoyrmcn7Zubd7lU3Pfssv2ZVidsMFIK277RZE9ka8hiNXO1fVo4qx5JqnmNQhtEBD0aDqpiVncYFhyglibmII-FhDImOIQgsSAwitMWMCo8cGoK514Kgea2O0jCukzyufdijwjmkSzNq5UPZuSkFCQa3KBw-CrMgZdiik_9uGkUl3fAtY7-Z_ZE933myHJimb30D)
* -7 bytes from removing unused variable, condensing string literals (@xigoi)
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 40 bytes
```
J"<tr>"AQ"<table>"J*H"<th>A"*tGJ*H"<td>A
```
[Try it online!](https://tio.run/##K6gsyfj/30vJpqTITskxEEgnJuWk2il5aXkA2Rl2jkpaJe4QToqd4///RjrGAA)
[Answer]
# [Dart](https://www.dartlang.org/), 45 63 bytes
### Working solution:
```
(m,n){print('<table><tr>'+'<th>A'*n+('<tr>'+'<td>A'*n)*(m-1));}
```
[Try it online here!](https://dartpad.dartlang.org/d4dc45371d8929ecd1cdbe671bb03ced)
Lambda/anonymous function taking `m` and `n` as parameters, displays output to `STDOUT`.
Since tables with unclosed `<table>`, `<tr>`, `<th>`, and `<td>` tags still render in modern browsers (ex., Chrome), the output is valid.
### Old (broken) solution:
My first attempt forgot to switch to `<td>` after the first row:
```
(m,n){print('<table><tr>'+'<th>A'*n+('<tr>'+'<th>A'*n)*(m-1));}
```
Thanks to @Lynn for pointing that out.
[Answer]
# Google Sheets, 66 bytes
```
="<table><tr>"&Rept("<th>A",B1)&Rept("<tr>"&Rept("<td>A",B1),A1-1)
```
Input is in cell `A1` and `B1`.
There's nothing fancy, really; it's just nested `Rept` functions.
It *does* assume `m > n > 0` and that they're both integers.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~33~~ 32 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
“<td>A”ẋ”h3¦s5ẋ€ṭ€“<tr>”ṭ“¢ssɱU»
```
A full program taking `rows`, `columns` which prints the result.
**[Try it online!](https://tio.run/##y0rNyan8//9RwxybkhQ7x0cNcx/u6gaSGcaHlhWbgthNax7uXAskwUqK7EAqgPyGOYcWFRef3Bh6aPf///@N/hsDAA "Jelly – Try It Online")**
---
hmm, also 32 using a table:
```
Ịị⁾hdṭ”t⁾<>j;ðþZṭ€“<tr>”ṭ“¢ssɱU»
```
[Answer]
# J, 64 bytes
Another port of the Python answer:
```
4 :0
'<table><tr>',(;y#<'<th>A'),;(<:x)#<('<tr>',(;y#<'<td>A'))
)
```
[Answer]
## PHP, 161 Bytes
[Try it online](https://tio.run/##XYzdCsIgGIZvZXx4oGBrOs@0YtcREWspBs2JfR1F1266k2AnD@8fb/Qxm1MsdO8w4WMJjaNk5iSwD8HDGXC8Pe0ROKBfeV@ZKs0eLtpOfmlemDBRMJ3poS3mmmy0I5ZEDEpAfWtBbbutl4OS/y0n805U2RWJTH@zo5L3TOcf)
**Code**
```
function f($m,$n){$t=["table>","th>","td>","tr>","</"];echo strtr("
<0<3".str_repeat("<1A41",$n)."43".str_repeat("<3".str_repeat("
<2A42",$n)."43",$m-1)."40",$t);}
```
**Explanation**
```
function f($m,$n){
  $t=["table>","th>","td>","tr>","</"];           //array representing the tags its created
  echo strtr("<0<3".str_repeat("<1A41",$n)."43"   //strtr it's called and uses
                                                  //the array to replace values
           .str_repeat("<3".                      //repeat the tags
                         str_repeat("<2A42",$n)   //repeat the tags again
                            ."43",$m-1)."40",$t);
   //its repeated m-1 times because head is counted as one row
  }
```
## PHP, 193 Bytes
Full table structure forgot `<tfooter>` `<thead>, <tbody>..etc..`
[Try example of the function](https://tio.run/##XY3LCsIwEEV/pQxdNBD7SEo3HSt@h4ikbUoF24Q4LkT89hojuMjmcs@ZC2Nnu@HB@pwe60BXsyZTli48Xdkrpf0JSPU33QEHmrUaQ@nN@PyZkJF0HZxbPcwmuZMjlwGWWEHu4eK01Yq8kUcsJHyf5IBFhSK6NxHXfl//941vy64KXWBReiTWvrcpE1yydvsA)
```
function f($m,$n)   {$t=["table>","thead>","tbody>","th>","td>","tbody>","tr>"];
echo strtr(
      "<0<1".str_repeat("<3A</3",$n).
      "</1<2".str_repeat(
                  "<6".str_repeat("<4A</4",$n)
                       ."</6",$m-1)."</2</0",
  $t);
  }
```
**Explanation**
`$t=["table>","thead>","tbody>","th>","td>","tbody>","tr>"];`
An array with all the tags for the table it's builded and then with `str_repeat` a number refering to an index in the array is written, **then** to `strtr` the string plus the array is passed
]


[Question]
      [
Given a string of printable ASCII text (including newlines and spaces) that contains at least one character that is neither a newline nor a space, output a truthy value if the string is rectangular, and a falsey value otherwise. **Additionally, the source code for your solution must be rectangular**.
A string is rectangular if it meets all of the following conditions:
1. The first line and the last line contain no spaces.
2. The first and last character of each line is not a space.
3. All lines have the same number of characters.
For example, the following text is rectangular:
```
abcd
e fg
hijk
```
This text, however, is not rectangular (requirement #3):
```
1234
567
8900
```
## Test Cases
Truthy:
```
sdghajksfg
```
```
asdf
jkl;
```
```
qwerty
u i op
zxcvbn
```
```
1234
5  6
7890
```
```
abcd
e fg
hijk
```
Falsey:
```
a b c
```
```
123
456
7 9
```
```
12
345
```
```
qwerty
 uiop
zxcvnm
```
```
1234
567
8900
```
---
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so the shortest solution in bytes wins.

[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~127~~ ~~125~~ ~~124~~ 118 bytes
* Saved two bytes by golfing `r*=!e&(!t|t==c);` to `r>>=e||t&&t-c;`. *(This golf was the inspiration for my recent C tips answer [Inverse flag update](https://codegolf.stackexchange.com/a/164010/73111).)*
* Saved a byte by golfing `*(_-2)` to `_[~1]`.
* Saved six bytes by golfing `*_++-10||(...)` to `*_++<11?...:0` and utilizing the placeholder zero `...:0` (which is not used constructively) to golf the `c++` increment. Those golfs allowed some further loop reshuffling.
* When one can use multiple falsey values, [114 bytes](https://tio.run/##hZDrbsIwDIV/b0@RVVqV9CK1tIWxEvEgyxS1ISmFYVgadiPs1UurDWlMWif5hyV/xz4@IqyEaFsdyEAEJudYLAvtcXJQW401NVTQKPd4V74/i@O59umNcV3cDQJJrPX4LEksf/iMH/vGmlAEgkoa3QvfJx4Pk5G1WNKY5NpS2QGu2zH5sd0UNWByuL7a6RqMwo5Bc3S7YOAEiGOnWVTLYrVuVOUQkv9FFc1CMVitn/Ih6vlVavPOYI9qtN0x@HgTLyUMKeJRkjLIEBozmNxNo0EPpeh6iVTFYFmv1t/s3jTYcX7K1KUMlUhc7lW/PTBIs94Bmg6DDJI0G0LOCaB9fQ4ANv8c7wMYTxh073/9f2xP) could be possible.
```
r,e,c,t;_(char*_){for(r=1,t=c=0;*_;*_++<11?r*=(t||(t=c,!e))&*_>32&_[~1]>32&t==c,c=e=0:c++)*_-32||(e=1);r>>=e||t&&t-c;}
```
[Try it online!](https://tio.run/##hZDrTsMwDIV/w1OESlRJm0pruwsjpHsQgqIuS7puzBtpxm0dr15awSSGRJH8w5K/Yx8fFRVKNY2lmirqmMRqmdtAkoPZWmx5TB1XfMAC2VYY3sXxzAYcu7rG7YBeaUL8QGZp4sv7j/ihaxxvB4prPrhVYUgCGaVJi2seE2azjOu6dr7vIsWOzSYvAZPD5cXOluAM9hyaoeuFAI8iib1qUSzz1boyhUcI@4vKq4URsFo/sj7q6UVb9yZgj0q03Ql4f1XPc@hTxEk6FDBCaCxgcjMd9HqYq7bXyBQCluVq/c3uXYU976fMnMvQHKnzvea3BwHDUecATftBAelw1IecEkD78hQAbP453gUwngho3//6/9h8Ag "C (gcc) – Try It Online")
*[Source layout achieving a taller rectangle.](https://tio.run/##hZDrboJAEIV/l6fYkpTscokiqLV09UG6zQaWXUTraJelN9FXp5jWpDYpTebHJPOdmTNHBIUQbat96QvfJByLZapdTvZqq7GmoW@ooMPE5V153r0VhgvtUmyaBncT/1oS4rh8Ho0c/nAMH0@Nod3AElTS4Z3wPOLyIBp1vKQhSfR8TmXTGMcxgUgOg0G7SUvAZG9d7XQJRmHboAW6yRnYPuLYrvJima7WlSpsQpK/qLTKFYPV@inpo55fpTbvDGpUou2OwcebeMmgTxGOopjBGKEJg@ntbNjrIRNdL5EqGCzL1fqbrU2FbfunTF3KUIbE5V712wODeHxygGb9IIMoHvch5wRQXZ4DgM0/x08BTKYMuve//j@0nw)*
# Explanation
*The following explains the 124 bytes long version.*
```
r,e,c,t;_(char*_){     // `r` is the boolean result flag, `e` a boolean flag if the current line contains
                       //  a space, `t` the first line's width, `c` the current line's current width
 for(r=1,t=c=0;*_;c++) // initialize, loop through entire string
  *_-32||              // if the current char is a space,
   (e=1),              //  the current line contains a space
  *_++-10||            // if the current char is a newline (char pointer `_` now incremented)
   (r*=(t||(t=c,!e))   // if t is not yet set, the current line is the first line; set it
                       //  to this line's length, check that no spaces where found
    &*_>32             // the next line's first char should not be a space
    &_[~1]>32          // this line's last char should not have been a space
    &t==c,c=~0,e=0);   // the line lengths should match, reset `c` and `e` to zero
                       //  (`~0 == -1`, countering the loop's increment of `c`)
 r>>=e||t&&t-c;}       // return boolean flag, check that the last line does not contain spaces,
                       //  there was either no newline or line lengths match
                       //  (here) equivalent to `r*=!e&(!t|t==c)`
```
[Try it online!](https://tio.run/##hVPbcpswEH1uvmLjmbpg44kd59IMQ/ohpQOyWEAxlhwh4lzc/Lq7ku04xAnlCdDu2XNZ8VHB@WajAwx4YMLE4yXTg8R/AfucnUGqUxA1mBJhplSFTILGuqkM5BUrAkgxBfZ2ZP@ByF05b7RGaaASkj6UNEzI@gQ@f2gSwdRLxpEwTeoQcqHrbf@PGlYiMyWd8fQInU73n67qBHKlPR1NAhPxaBwOkpAPh74dIqQwglXimcZUSi0JS6umKIGahUaojRayIJaDZDQ9X6@PWH4QZ@2y/uy5W30eRhM/ONb3pSn7bjd2OBxNxu3BXWMlrhyWCw6WSkiDGtIkBalWJJdrXFAHZr6jpgeRZ9Zrj4wJTtH3D@gWTioDT2igRhMc092twSGV0BaCMF2hGkVN1LnLqUJZ2Bh5iXxOJ8zQ0K16irhEiiBXjcwcZH@Q3E7PP0JaDhIf36Lf8nHy61I1VeZkzPCdqwSV/H6d/GmhOah3zNgnKCV7oL1HlG0wE5F9PHodBxiN/fDAy/m01VjvcRbMcFJMt4bMsuvLZOauDVnzjFp1ueelr2OIIhhNUvKMjKFwaT@3s2h9ifdbxKByC08569vbCNdr0@@bEQ//HvA0mkbL1m1tReFg2S5dyBRuV2K3p7uYgs64XYQrVgMK@27T3a@o0m1/nDGd6i2YD3jfiAdWWYlkWUorfIp979SsbQx@ulkQN89/Ofm2JG9M7vUM/ILvWSx7ASRer86Kkt3N67zo@X74VRWrszyWd/Mq7Kq6X6E2T7FsQIBaxvL5kT/MZFfH5Hx6EctLgKtYXv@8GXdymHF6pxtQxLIUd/NdbWNqr9d735a322AGvI2bf@QQy4tLywBuugtjOb247CrZOwCN2BsgF/8Zbg24uo4lyd/q/7v5Bw "C (gcc) – Try It Online")
[Answer]
# Java 10, ~~214~~ ~~176~~ ~~169~~ ~~152~~ ~~144~~ 139 bytes
```
s->{String[]a=s.split("\n")
;int r=1,i=0,R=a.length;for
(;i<R;i++)if(i<1|i>R-2?a[i]
.contains(" "):a[i].trim( )
!=a[i])r=0;return-r<0;}////
```
-5 bytes thanks to *@Neil*.
Uses `String[]a` instead of `var a`; `return-r<0;` instead of `return r>0;`; and added a comment `//` at the very end, so there aren't spaces on the first and last rows.
Note that this rectangle is shorter than a single-line input, because `int r=1,...;` should be replaced with `int[]v{1,...};`, and all uses of the integers would then becomes `v[n]` (where *n* is the index of the variable in the array `v`).
[Try it online.](https://tio.run/##rVTPU@IwFL73r3jmlAxSQFF3LXVv3vQAe7Me0jQtKSHpJimKyt/OBpTZmR0lOEOmObzme@97v@ar6YJ262K2ZpJaC3dUqNcIQCjHTUkZh/uNCZBrLTlVwPDEGaEqsCTxDyt//WcddYLBPShIYW27N6/vqIdHmtrYNlI4jDKFSJT4yGDSwalI@6fjlMaSq8pNk1KbCCdiNE5Ep0NEicVo8CZuxt2zX/RBPEYx08r55CxGgMj15l/sKeYYSHSSbkxi0n5iuGuN6ppRP1n1/FlvkmzaXPrsPpJcaFHA3IfCuxyBkvciez34bVo3XV5vzcnSOj6PdevixiOdVFjFDCOas8IX09mCvjiIQ1kFQVNRzxDZdvJrOltUU1rPbFkFodQWZZC0nskkGOnPEzduGYzVggDdBGEvz2yRqyDp4Ox8GIx1AXAZBF39@NkPd@v4c9yt0S2VlgfW6LBqL68gCPLFHlAt5MAOGEGY7nx4caz9gVboBg7aHzU/0v58q6O7gU50a7waMl1wEM5yWe4f7ucamKEsUxkiQf49Mhn03SOjQd9/MpshyP4T2qD3HiH@mN0qWq3/Ag)
**Explanation:**
```
s->{                        // Method with String parameter and boolean return-type
  String[]a=s.split("\n");  //  Input split by new-lines
  int r=1,                  //  Result-integer, starting at 1
      i=0,                  //  Index `i`, starting at 0
      R=a.length;           //  Amount of rows `R`
  for(;i<R;i++)             //  Loop `i` over the rows
    if(i<1                  //   If it's the first row,
       |i>R-2?              //   or the last row:
        a[i].contains(" ")  //   And the current row contains a space
       :a[i].trim()!=a[i])  //   Or either column of the current row contains a space
      r=0;                  //    Set the result `r` to 0
   return-r<0;}             //  Return whether `r` is still 1
////                        // Comment to comply to the rules of the challenge
```
Here is the same base program with spaces (**~~128~~ 126 bytes**):
```
s->{var a=s.split("\n");int r=1,i=0,R=a.length;for(;i<R;i++)if(i<1|i>R-2?a[i].contains(" "):a[i].trim()!=a[i])r=0;return r>0;}
```
-2 bytes thanks to *@Neil*.
[Try it online.](https://tio.run/##rVTPU@IwGL3zV3zm1AxSQFF3DWVv3vQAe7Me0jQtKSHpJimKyt/OBhbG2XEkOEOmPXzty/ve92NeRRe0U@WzNZPUWrinQr21AIRy3BSUcXjYhACZ1pJTBSyaOCNUCRYT/2PlX/9YR51g8AAKEljbzuhtQQ3QxMa2lsJFKFUIE08KJumfi6R3Pk5oLLkq3ZQU2kREDMdEtNtYFJEY9t/FaNy5@EUfxVPMtHJelY0QIHy7/eQVzCN8lmwCbJIeMdw1RoEZ9chqTVpeUd1k0ivaCVtokcPcs@zUPz4Bxf8K63bht2ncdHm7DSdL6/g81o2La490UkUqZhGiGct9Ee0t6IuDOBRlEDQV1Qzhbfe@TmfzckqrmS3KIJTavAgmrWaSBJn@PHPjlkGuBgToOgh7fWGLTAWT9i8uB0GuK4DrIOjmx89euFunn@N@je6otDywRsdVe30DQZAv9ohqIQN2xAjC6S4HV6faH2iEruGo/VHzE@3Ptzq6H@hEN8Y7INM5B@Esl8Xh4W58b@8vH96XojRVKcLB/Af8MXj3gIEG7344bIog/c9jIaz6kwt3zNC7cNef3exWrdX6Lw)
[Answer]
# T-SQL, ~~237~~ 207 bytes
```
SELECT(SELECT(IIF(max(len(v))=min(len(v)),1,0)*IIF(SUM(len(v+'x')-len
(trim(v))-1)=0,1,0))FROM t)*(SELECT(IIF(SUM(charindex(' ',v))=0,1,0))
FROM[t]WHERE[i]IN(SELECT(min(i))FROM[t]UNION(SELECT(max(i))FROM[t])))
```
Outputs 1 for rectangular, 0 otherwise. I had to use tons of extra parens and brackets to eliminate spaces, I'm sure there is vast room for improvement.
**Explanation**:
[Per our allowed I/O options](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341) and clarification in the question comments, input is taken as separate rows in a pre-existing table **t**. Because data in SQL is inherently unordered, that table includes a "row number" identity field **i**:
```
CREATE TABLE t (i INT IDENTITY(1,1), v VARCHAR(999))
```
Basically my SQL performs 3 subqueries, each of which returns `0` or `1` based on the 3 criteria of "rectangular" code. Those 3 values are multiplied together, only returning `1` for code that satisfies all 3.
**EDIT**: Combined criteria 2 and 3 into the same SELECT to save space
```
SELECT(
SELECT(IIF(max(len(v))=min(len(v)),1,0)                  --All rows same length
      *IIF(SUM(len(v+'x')-len(trim(v))-1)=0,1,0))FROM t) --no leading or trailing spaces
*(SELECT(IIF(SUM(charindex(' ',v))=0,1,0))               --No spaces at all in
FROM[t]WHERE[i]IN(SELECT(min(i))FROM[t]                  --   first row or
            UNION(SELECT(max(i))FROM[t])))               --   last row
```
The `TRIM(v)` function is only supported by SQL 2017 and above. Earlier versions would need `LTRIM(RTRIM(v))`, which would require rebalancing the rows.
One random note: the `LEN()` function in SQL ignores trailing spaces, so `LEN('foo ') = 3`. To get a "true" length you have to tack a character on to the end then subtract one :P
[Answer]
# C++, ~~199~~ ~~183~~ ~~181~~ 175 bytes
This template function accepts lines as a collection of strings (which may be wide strings), passed as a pair of iterators.
```
#include<algorithm>//
template<class I>bool
f(I a,I b){return!~+(
*a+b[-1]).find(' ')&&
std::all_of(a,b,[&a](
auto&s){return' '+-s.
back()&&s[0]-' '&&a->
size()==s.size();});}
```
Thanks are due to user [Erroneous](/users/42487) for reminding me of the `back()` member of `std::string` and for pointing out that `npos+1` is zero.
## Ungolfed equivalent
The only real golfing is to concatenate the first and last lines so we can perform a single `find` for spaces in those.
```
#include <algorithm>
template<class It>
bool f(It a, It b)
{
    return (*a+b[-1]).find(' ') == a->npos
        && std::all_of(a, b,
                       [=](auto s) {
                           return s.back() != ' '
                               && s.front() != ' '
                               && s.size() == a->size(); });
}
```
# Test program
```
#include <iostream>
#include <string>
#include <vector>
int expect(const std::vector<std::string>& v, bool expected)
{
    bool actual = f(v.begin(), v.end());
    if (actual == expected) return 0;
    std::cerr << "FAILED " << (expected ? "truthy" : "falsey") << " test\n";
    for (auto const& e: v)
        std::cerr << "  |" << e << "|\n";
    return 1;
}
int expect_true(const std::vector<std::string>& v) { return expect(v, true); }
int expect_false(const std::vector<std::string>& v) { return expect(v, false); }
```
```
int main()
{
    return
        // tests from the question
        + expect_true({"sdghajksfg"})
        + expect_true({"asdf", "jkl;",})
        + expect_true({"qwerty", "u i op", "zxcvbn",})
        + expect_true({"1234", "5  6", "7890",})
        + expect_true({"abcd", "e fg", "hijk",})
        + expect_false({"a b c",})
        + expect_false({"123", "456", "7 9",})
        + expect_false({"12", "345",})
        + expect_false({"qwerty", " uiop", "zxcvnm",})
        + expect_false({"1234", "567", "8900",})
        // extra tests for leading and trailing space
        + expect_false({"123", " 56", "789"})
        + expect_false({"123", "45 ", "789"})
        // the function source
        + expect_true({"#include<algorithm>//",
                       "template<class I>bool",
                       "f(I a,I b){return!~+(",
                       "*a+b[-1]).find(' ')&&",
                       "std::all_of(a,b,[&a](",
                       "auto&s){return' '+-s.",
                       "back()&&s[0]-' '&&a->",
                       "size()==s.size();});}",})
        ;
}
```
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 85 bytes
```
x=>(x=x.split`\n`).some(s=>s.length-x[0].length|s.trim()!=s)<!/\s/.test(x[0]+x.pop())
```
[Try it online!](https://tio.run/##jZBdT8IwFIbv@RWHq7UhFJQNJDD@iDNhH93WrWvHTsFq/O9T1DRGbcLdeZPnPXnzNOklxXwQvZkrXfCxjEcbH4iNLcNeCnNM1JEy1B0nGB@QSa4qU8/t4/Lp@35DZgbRETqNke6niwQXzHA05MrMLOt1Tygdc61QS86krkhJJgABFlWdNi2WVUDpbvIXSLEoExXA7BqaVu483OmZD@bFkWcQoHsXX21@yZSnene/Ch0ZAaxd2Dxsl75dWV44jkNZuVCLpv0s/deCDHL/DPcjjH6MgK234aBVGN0mBs7ilxfV3eRlvQEXPrR8eRnfAQ "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 82 bytes
```
lambda*s:len(set(map(len,s)))<2<'!'<=min(tuple(s[0]+s[-1])+zip(*s)[0]+zip(*s)[-1])
```
[Try it online!](https://tio.run/##rZBLcoMwEET3c4rJShKOUzYGO3bgJMYLPsKIj5AZkcS@PBFUOblAdt1T3a@qx9xt1Wt/KuNkatMuK1KPTq3UnKTlXWq4068khIj8iL2wKO6U5nY0reR03lxWdF5vL2L1UIZ7JObLU873yUqyhDEOjDEqrlVaN1ReAVIqSqib9gPg9iUHe4cRFfYGHt/5Z6YBtv4ugBBxD4f348YVsrwAia5bqbpxHjPMlxgEoQvhcTYIuyD8ReKoeoMLUndP5P4ADuiI/7/WbXwj0yrLWaITzQRA2Q9oUWlcHnFCMyhtseSe/UsyIWD6AQ "Python 2 – Try It Online")
Invoke as `f("abcd", "e fg", "hijk")`.
[Answer]
# [Haskell](https://www.haskell.org/), ~~106~~ ~~102~~ ~~98~~ ~~110~~ ~~109~~ 102 bytes
```
(\a->all(==[])a||and(e((1<$)<$>a):map(all(>='!').($a))[head,last,map$last,map$head]));e(a:s)=all(==a)s
```
Thanks to @nimi and @Laikoni for a byte each!
[Try it online!](https://tio.run/##vY9NDoIwEIX3nmIkJM4kSOJWLTfwBJTFiEUbS60Uf@PZrajowgO4ei/ve5mX2bDfKmNCJWRAyeOMjUEh8oL4dmO7QoU4mcc0jzOmac0On4VMjIYjSjFmonyjeJUY9m3S4fhrnnFBNFPIU0/ifZfJh5q1BQFdZwHoGm3btEqNtsoTDAByiBiWUEadTyDan1TTXqSFg945aa/n8mjrH3YADR@4tD1E@Zd3@rVe5Gu9CPeyMrz2YVw69wA "Haskell – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 79 bytes
```
g(x:r)=all((==(0<$x)).(0<$))r&&all(>='!')(x++last(x:r)++(head<$>r)++(last<$>r))
```
[Try it online!](https://tio.run/##tY9BDoIwEEX3nmIkBDqpIRp3SrmBJwAWRRtoLBULaPXyFRrcuHcx@T//TeZnGt5fhVLO1cQeDDKuFCGMkW0aWsRkVkQTRXOesXgdI7GUKt4Pfp9S0gh@ScPM@zn3Ho91XrJdunctlxoYtLw7AemM1AMkUE@jpBY9wgogh4BDBedg8hsI7k9hhlehYZS3rtBve37o9oeNIOELK73AP72wXF@k8G2l@wA "Haskell – Try It Online") Takes input as a list of lines.
The pattern `g(x:r)= ...` binds the first line to `x` and the (possibly empty) list of remaining lines to `r`. Then `all((==(0<$x)).(0<$))r` checks if all lines in `r` have the same length as `x` (Using [this tip](https://codegolf.stackexchange.com/a/146634/56433)).
If not, then the conjunction `&&` short-circuits and returns `False`, otherwise the right hand side is evaluated. There a string is build which consists of `x` for the first line, `last(x:r)` for the last line of `r` (or the first line again in case `r` is empty) and `(head<$>r)` for the first and `(last<$>r)` for the last character of each line. For this string, `all(>='!')` checks that it does not contain any spaces (we can't use `(>' ')` because of the source code restriction).
[Answer]
# [MATL](https://github.com/lmendo/MATL), 13 bytes
```
ctgF6Lt&()32>
```
Input is an array of strings, in the format `{'abc' 'de'}`.
Output is an array containing only ones, which is [truthy](https://codegolf.stackexchange.com/a/95057/36398), or an array containing at least a zero, which is [falsey](https://codegolf.stackexchange.com/a/95057/36398).
[Try it online!](https://tio.run/##y00syfn/P7kk3c3Mp0RNQ9PYyO7//2r1xKTkFHUdBfVUhbR0EJ2RmZWtXgsA "MATL – Try It Online") Or [verify all test cases](https://tio.run/##VY7NTsMwEITvfoq9UDeXqDQ/pUKCS0FC4tgrEk5sJ05cO8QOJVR99rCkUCU@eHdnNPvtgXk9vMP13cDOhmF4LJUWsFRGKqO8AG1tEwy5L57TV79YBtH6YXicpl4kob7tfNlTcp4aT9oJQiXDgtbbzDKc7GZo5RrNerKfivu2w0t@D4DcGq68siYYTtTxomRV7WRBz@REmeOSAq1qfT/OH0fR@h6VDhTYBpvvr/wzM6N5u45iVBKAFMvmbru67MhyjrMA3Am0VFV9kSGD/D@HRpyMKdj@aThEcTKnQqeuUHOYQdMN/ohE5g8), including truthiness/falsihood test.
### Explanation
```
c       % Implicit input. Convert to char. This concatenates the
        % strings of the input cell array as rows of a rectangular
        % char array, right-padding with spaces as needed
tg      % Duplicate, convert to logical. Gives a logical array with
        % the same size containing true in all its entries
F       % Push false
6L      % Push the array [2, j-1], where j is the imaginary unit.
        % When used as an index, this is interpreted as 2:end-1
t       % Duplicate
&(      % Assignment indexing with 4 inputs: original array, new
        % value, two indexing arrays. This writes false at the inner
        % rectangle (2:end-1)×(2:end-1) of the logical array that
        % initially only contained true. This will be used as a
        % logical index (mask) into the rectangular char array
)       % Reference indexing. This selects the border of the char
        % array. The result is a column vector of chars
32>     % Is each entry greater than 32? (ASCII code for space)
        % Implicit display
```
[Answer]
# JavaScript (ES6), 88 bytes
```
s=>!s.split`\n`.some((s,i,a)=>s[L='length']-a[0][L]|(++i%a[L]>1?/^\s|\s$/:/\s/).test(s))
```
[Try it online!](https://tio.run/##jZDtboJAEEX/@xTTpA27QUEraK2BvoBvADQusMAC7lJntR/x3am2yaZpS@K/ucm5k5tTsyPDbC86PZEq530R9BiEN@hg1wq9jeXWQbXjhOBYjBkNQow2gdVyWerKSiYsmibRJjkR2xZ37HyFsyf3OcZTjLfuoxujSx3NUROktM@URNVyp1UlKcgIwMK8rFjdYFFalK5HfwGGeRFLC@xLqJt2PcC9vPK9fjfkAQSozsSPt@yYyoHq7H7uGdIHWJiwfFhNh3alWW44DkVpQiXq5qv0XwtSyIZnmB@e/2MErAYbBpp7/nVi4CB@eZG7q7wslmDCWcu3l/4T "JavaScript (Node.js) – Try It Online")
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~17~~ 15 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
４［↷Ｋ；｝┐）｛ＳＬ］∑４≡
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JXVGRjE0JXVGRjNCJXUyMUI3JXVGRjJCJXVGRjFCJXVGRjVEJXUyNTEwJXVGRjA5JXVGRjVCJXVGRjMzJXVGRjJDJXVGRjNEJXUyMjExJXVGRjE0JXUyMjYx,i=JTYwJTYwJTYwJTBBMTIzNDUlMEE2JTIwJTIwJTIwJTBBMyUyMCUyMCUyMDMlMEE4OTEyMyUwQSU2MCU2MCU2MA__,v=2)
Explanation (ASCII-fied for monospace):
```
4[↷K;}┐){SL]∑4=  full program; pushes the input to the stack.
4[   }           repeat 4 times
  ↷                rotate ToS clockwise. This also pads the input with spaces
   K;              take off the last line and put it below the item
      ┐          pop the remaining of the input (the center)
       )         and wrap the rest (the sides) in an array
        {  ]     map over those
         S         split on spaces - should result to one item in the array
          L        and get the length
            ∑    sum those lengths together
             4=  check if equal 4
```
[Answer]
# [Perl 5](https://www.perl.org/), 70 bytes
```
$f||=$_;$l||=y///c;$,||=/^\s|\s$/||$l-y///c;$e=$_}{$\="$f$e"=~/\s/||$,
```
[Try it online!](https://tio.run/##LYoxCoAwEAR7XyGypXKVleQnQVFJRAgmGC3E06d7RrCagZlgVleLwDIrdA1c4kFEY4MyKbU6so4gZrjqDyad1wmtCliYQt2k4zeUIv0wZjb32eT3x4dt9kuUKrgX "Perl 5 – Try It Online")
Outputs `0` for truthy, any other number for falsey.
[Answer]
# [Red](http://www.red-lang.org), 216 191 bytes
```
func[s][d:(length?(first(s:(split(s)"^/"))))sp:
func[a][none = find a" "]b: on foreach c s[b: b
and(d = length? c )and(c/1 <>" ")and(" "<> last
c)]res:(sp(first(s)))and(sp(last(s)))and(b)res]
```
[Try it online!](https://tio.run/##bY7NTsMwEITv@xQrn5JTKbRArVLegatlJP82huAE2@FXffawiUrLAV/smfl2x8nZ8cFZIcHz0Q/RiCyF5VXr4r4095UPKZcq8yr3baBHzR4XrKaTew4zr6SIXXR4hz5Ei4ohk5pjF9F3ySnToMEsyNGgoq0sgcflFNSTZRZL3O5oblZ0b3fYqlzA1DK5ufv3H1Q8MWRMwEnrmjg59inEgh6@lTYWHPo9NOHp@QBwSl7fXSqfMGDAroevD/Om4998eXm1gjXiNdzcbi7OCTKFGg07GzMLqzWRuPmnAodwbIgvh/EH "Red – Try It Online")
I put a lot of otherwise not necessary parentheses in the first and last rows.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 17 bytes
```
Ỵµ.ịÐ€;ịɗẎ⁶e<L€E$
```
[Try it online!](https://tio.run/##y0rNyan8///h7i2Htuo93N19eMKjpjXWQMbJ6Q939T1q3JZq4wMUcVX5//9/YXlqUUklV6lCJldVRXJZUh4A "Jelly – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 15 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
Uses a method developed by Mnemonic in a (currently - due to an edge-case failure) deleted Pyth submission. (if it is now fixed up, [go give some credit](https://codegolf.stackexchange.com/a/163978/53748)!)
```
ỴµL€Eȧt€⁶ZUƊ4¡⁼
```
A monadic link accepting a list of characters which returns 1 or 0.
**[Try it online!](https://tio.run/##y0rNyan8///h7i2Htvo8alrjemJ5CZB61LgtKvRYl8mhhY8a9/z//z8xKTmFK1UhLZ0rIzMrGwA "Jelly – Try It Online")**
### How?
```
ỴµL€Eȧt€⁶ZUƊ4¡⁼ - Link: list of characters
Ỵ               - split at newlines (making a list of lists - the rows)
 µ              - start a new monadic chain, call that ROWS
  L€            - length of €ach row in ROWS
    E           - all equal? (an integer: 1 if so, otherwise 0)
            4¡  - repeat four times:
           Ɗ    -   last three links as a monad:
      t€⁶       -     trim spaces (⁶) from €ach row in current ROWS
         Z      -     transpose that result
          U     -     upend (reverse each new row)
     ȧ          - logical AND (0 if L€E was 0 else the result of the repeated transform)
              ⁼ - equal to X? (the integer 0 is not equal to any listy of characters)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 22 bytes
Noncompeting answer: there's a [known bug in Japt](https://github.com/ETHproductions/japt/issues/38), where two-dimensional array rotations truncate the results. Due to that bug the code below only works on inputs that are square. If the bug wasn't present, though, the code below should work completely correctly.
```
e_Ê¶UÌÊÃ©Ueº4o)r_z)mx}U
e_                      // Check if every line in the input array
  Ê¶UÌÊ                 // has the same length as the last item.
       Ã©               // Also,
               r_z)mx}U // check if rotating and trimming the input array
           º4o)         // four times
         Ue             // is equal to the input array.
```
Takes input as an array of strings. Using parentheses instead of spaces makes the rectangular code requirement quite easy.
[Try it here](https://ethproductions.github.io/japt/?v=1.4.5&code=ZV/KtlXMysOpVWW6NG8pcl96KW14fVU=&input=WyJhYmMiLAogImQgZSIsCiAiZmdoIl0=).
[Answer]
# [Ruby](https://www.ruby-lang.org/) 2.5+, 63 bytes
```
->a{!a.uniq(&:size)[1]&&a.none?(/^\s|\s$/)&&!(a[0]+a[-1])[?\s]}
```
Takes input as an array of strings. No test link, since the version on TIO (2.4) is too old for this one. Instead, here is a slightly longer (69 bytes) version for testing:
```
->a{!a.uniq(&:size)[1]&&a.none?{|l|l=~/^\s|\s$/}&&!(a[0]+a[-1])[?\s]}
```
[Try it online!](https://tio.run/##PY3tboJAFET/36dYE0MgrQsoaK2lPAjQ5AKLLB8LstBWgb66ro3tr8kkZ850Q3y@Zt519Y7jAukg@EnXXiW/MCOwI01DKhrB/HGqpsr7MT9COYVyac6attAxsKInDFZ2ZAR@KKP5unyjHcOUyrbivW6GYlzPpkEZJvk49Uz2E3r3eAB@KAxaY6sek7ypW@PQEnzOAlQqmR5zLEqZHQFQphkUZXUAOH2xrj/DQDhpWrh8J5@xALDXGwdcQrawe9lbahAnKTCitjkvStVJTJJfDBxXQWR/L7Bx3H8jGfhDKOo/4XYHSmfdAA "Ruby – Try It Online")
The difference is that since 2.5 Ruby supports directly passing a Regex pattern to `all?, any?, none?` methods, which saves us a few bytes. The method itself is quite self-explanatory - we test:
1. If there is only 1 unique line size
2. If there are any spaces on line boundaries
3. If there are spaces on the first and last lines.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 119 bytes
Takes input as a list (s) of n strings.
```
f(s,n,m,r,p)char**s,*p;{for(r=m=n;m--;r*=strlen(*s)==strlen(s[m])&(!p||m&&m^n-1&&p!=s[m]&&p[1]))p=strchr(s[m],32);n=r;}
```
[Try it online!](https://tio.run/##xZLJboMwEIbP4SkmlooMMlLZ0gVx7Qu0tySViFmTYKgNbdM0z56aJURJuJcDzOBv5h/PDDUSSo/HGAvCSE44KTWaBlzXBdFLbx8XHHM/95mXG4bHdV9UfBsxrAvNP9lini81FU/L399cVfN3ZpiqWk795r805uZS08oGpilvYWJbmsd87h2On0UWQoIbSWg0IWMVME3ZK5OSSzvG6C5cMESgqVCeaJ5yUJSGyoOM4ZakBRMVdDkqXkfmfAk@7JEIkzRYb0ScoIN3i1k9FogwRgStN1tvlLN77uMr4tVOkjVkUJTS@Pmmnys2GuT0QaZlO5J0AWby8/D4dD@Ku6daVjSUXASyZoLSbL1p8cuAONiK4ZIBrIDe5GwR61yDTOa4bQXwNA7bAywp23HHKee6F1BnQytYPh7kXvVi9iDfshP3I3ejRRj1@D/tZF9UWVcCozdeV@nuecEM@SC5fJMEtytGwDx7FgHr7NkE7LPnXHhu753yL9hL06ErhW7Ag0Q3zCFPN65BspvL5emtzGu0jS9Fmk53EofjHw "C (gcc) – Try It Online\"nline")
[Answer]
# [C# (.NET Core)](https://www.microsoft.com/net/core/platform), ~~145~~ 167 bytes
```
S[0].Length>1&&S[0].IndexOf
(" ") + S[ S.Count() - 1 ].
IndexOf(" ")<-1&Array.Find(
S,x=>x[0]==' '| x [x.Length
-1]  ==  ' '  | S[0].Length
!=x.Length)==null?11>0:0>1;
```
[Try it online!](https://tio.run/##nVNdb9owFH1ufsVZHiDRRkRWaNdlYZqqMk3qtGmZtAfMQ0hMMJgbajtd6MdvZ4aWDSFtUnbfrn0@ro@uM93JSsU3lRZUIFlrw5eRc9gFl6WUPDOiJB185MSVyI4Q14Jujo6@89oE33hRyVRd1SvFtd4KRE4mU63xVZWFSpe4d2BLm9SIDLelyPE5FeRpo6zWaIxUFdrHDvQE3dalFSolD34oYbj15t7Qc3VezNL5Qk8L9@QkSFZSGK/NqO37fvRvZqrzKaP5QkZNmTc/uTJrRhUEyhWjuzq7nZDbTCR8fdpj1AfOGJ2/ueg2Hn@S5Yw4pgWjmZgvGvMxQWZJjadm1OtvZ8aF25jM6LTXb2y6zxuV2MdNy/@L@@yckQ37b2k//hY5XNBJWUoM/2xn4h9tpuKmUoRNMuqOg2tOhZkNwlZr136inNdfpo7nwvXxEskIif1bFRnPRwchxoHzjNlB3nXC1gel0nUwFJR7TvKqjge1VYrjNtoPqDGqnz2cTjgG4hiwN8ADDvydF/Ee5scxVVK@D8NB9213EEabp6c@bn4B "C# (.NET Core) – Try It Online")
```
S[0].Length>1&                                    // And if the lenght of the first argument is more than 1 char
Array.Find(                                       // Find a string in an array
    S,                                            // The array which will be searched in
    x=>                                           // For x as the current string from the array
    x.Length!=S[0].Length|                        // If the string lenght match not the first argument lenght
    x[0]==' '|                                    // Or if the string begins with a spacer
    x[x.Length-1]==' '                            // Or if the string ends with a spacer
)==null&                                          // And if there was no string found which matched the conditions
S[0].IndexOf(" ")+S[S.Count()-1].IndexOf(" ")<-1  // And if the first and last string doesn't have a spacer
?                                                 // If all above is true do
1>0                                               // Return True
:                                                 // Else
0>1                                               // Return False
```
]


[Question]
      [
A current internet meme is to type 2spooky4me, with a second person typing 3spooky5me, following the `(n)spooky(n+2)me` pattern.
Your mission is to implement this pattern in your chosen language. You should write a program or function that takes a value `n` (from standard input, as a function argument, or closest alternative), and outputs the string `(n)spooky(n+2)me` (without the parentheses; to standard output, as a return value for a function, or closest alternative).
Your solution should work for all inputs, from `1` up to 2 below your language's maximum representable integer value (`2^32-3` for C on a 32-bit machine, for example).
Example implementation in Python:
```
def spooky(n):
    return "%dspooky%dme"%(n,n+2)
```
`spooky(2) -> "2spooky4me"`
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so [standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden, and the shortest answer in bytes wins!
# Leaderboard
The Stack Snippet at the bottom of this post generates the leaderboard from the answers a) as a list of shortest solution per language and b) as an overall leaderboard.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
```
## Language Name, N bytes
```
where `N` is the size of your submission. If you improve your score, you *can* keep old scores in the headline, by striking them through. For instance:
```
## Ruby, <s>104</s> <s>101</s> 96 bytes
```
If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the *last* number in the header:
```
## Perl, 43 + 2 (-p flag) = 45 bytes
```
You can also make the language name a link which will then show up in the snippet:
```
## [><>](http://esolangs.org/wiki/Fish), 121 bytes
```
```
<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 290px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 62350; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 45941; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>
```

[Answer]
# O, 20 characters
```
Q"spooky"Q2+"me"+++p
```
Sample run:
```
bash-4.3$ o.sh 'Q"spooky"Q2+"me"+++p' <<< 42
42spooky44me
```
[Answer]
# [Fourier](http://esolangs.org/wiki/Fourier), 32 bytes
```
I~zo115a-3avaa-4a121az+2o109a-8a
```
Still using @isaacg's golfing algorithm ;)
[Answer]
# Haskell, 38 bytes
```
a n=show(n)++"spooky"++show(n+2)++"me"
```
Defines a function named `a` that takes a `Num` `n`. Returns `<n>spooky<n+2>me`.
[Answer]
## Clojure, 26 bytes
```
#(str %"spooky"(+ 2%)"me")
```
First post. It's a function, as required. I *think* I took as many liberties with the tokenizer as possible, but I don't know. Here it is in action in the REPL:
```
user=> #(str %"spooky"(+ 2%)"me")
#<user$eval1176$fn__1177 user$eval1176$fn__1177@2d2d2f69>
user=> (*1 55)
"55spooky57me"
```
[Answer]
# Dart, 27 Bytes
```
t(n)=>'${n}spooky${n+2}me';
```
Unremarkable but competitive.
[Answer]
# Factor, 79 bytes
```
: f ( x -- ) dup 2 + [ number>string ] bi@ "spooky" swap "me" 4array concat . ;
```
First stab at it, just did it the obvious way.
[Answer]
## Lua, 41 Bytes
There's [this other lua answer](https://codegolf.stackexchange.com/a/62410/41019), but it doesn't work anymore since lua 5.3. It will now print `2spooky4.0me` Here comes a code working under all versions of lua, and who's still in 41 Bytes:
```
print(("%dspooky%dme"):format(...,...+2))
```
[Answer]
# [,,,](https://github.com/totallyhuman/commata), 18 [bytes](https://github.com/totallyhuman/commata/wiki/Code-page)
```
:↓2+"spooky"↓↓"me"
```
[Answer]
# [Acc!!](https://github.com/dloscutoff/Esolangs/tree/master/Acc!!), 99 bytes
```
N
Write _
Write 115
Write 112
Write 111
Write 111
Write 107
Write 121
Write _+2
Write 109
Write 101
```
[Try it online!](https://tio.run/##S0xOTkr6/9@PK7wosyRVIR5KGxqawllGcJYhJsvAHMYygonFa8N1GFjCWYb//xsDAA "Acc!! – Try It Online")
[Answer]
# [Implicit](//git.io/sS), ~~20~~ ~~17~~ 16 bytes
```
ì¯spooky]ì..ìme"
```
[Try it online!](https://tio.run/##K87MLchJLS5JTM7@///wmkPriwvy87MrYw@v0dM7vCY3Ven/f0MjAA)
```
ì¯spooky]ì..ìme"
ì                 « implicit integer input, convert to string     »;
 ¯                « copy input to memory                          »;
  spooky          « push the ASCII character codes for each letter in `spooky` individually »;
        ]         « copy memory to stack                          »;
         ì        « convert string to integer                     »;
          ..      « increment twice                               »;
            ì     « and back to string                            »;
             me   « push character codes for `me`                 »;
               "  « stringify the entire stack                    »;
```
[Answer]
# [Python ≥ 3.6](https://docs.python.org/3/), 28 bytes
```
lambda x:f'{x}spooky{x+2}me'
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaHCKk29uqK2uCA/P7uyukLbqDY3Vf1/QVFmXolGmoaRpuZ/AA "Python 3 – Try It Online")
Makes use of [formatted string literals](https://docs.python.org/3/whatsnew/3.6.html#whatsnew36-pep498), a feature that was introduced in Python 3.6.
[Answer]
# SmileBASIC, 26 bytes
```
INPUT N?N;"spooky";N+2;"me
```
[Answer]
# T-SQL, 40 bytes
```
SELECT CONCAT(n,'spooky',n+2,'me')FROM t
```
Input taken via a pre-existing table **t** with integer column **n**, [per our input standards](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341).
`CONCAT` does an implicit type conversion, otherwise I'd have to do something like `CONVERT(n,varchar(9))`.
[Answer]
## [OCL](http://ostracodfiles.com/pumpkin/ocl2.html), ~~52~~ 46 bytes
```
Function a b Print b+"spooky"+(b + 2)+"me" End
```
This one is pretty straight forward, I just wanted to show off an obscure language.
Edit: I found out you can omit the spaces between the pluses when doing concatenation, but not addition. Weird.
[Answer]
# [Pip](https://github.com/dloscutoff/pip), 23 bytes
```
(a:q)."spooky".a+2."me"
```
[Try it online!](https://tio.run/##K8gs@P9fI9GqUFNPqbggPz@7UkkvUdtITyk3Ven/f2MA "Pip – Try It Online")
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 14 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ü╫2┐╚╘Wö»§W╟╛╨
```
[Run and debug it at staxlang.xyz!](https://staxlang.xyz/#p=81d732bfc8d45794af1557c7bed0&i=3)
### Unpacked (16 bytes)
```
.me;2+`tNCrf`,Wp
.me                 Literal "me"
   ;2+              Peek from input stack, push to stack, and add 2
      `tNCrf`       Literal "spooky"
             ,      Pop from input stack; push to stack
              Wp    Pop and print everything from the stack with no additional newlines
```
[Answer]
# Excel, 22 bytes
```
=A1&"spooky"&A1+2&"me"
```
[Answer]
# [Runic Enchantments](https://github.com/Draco18s/RunicEnchantments/tree/Console), 18 bytes
```
i:2+"me"S9´334E{@
```
[Try it online!](https://tio.run/##KyrNy0z@/z/TykhbKTdVKdjy0BZjYxPXaof//40A "Runic Enchantments – Try It Online")
Saves 1 byte by using `9´334E` to pull "spooky" out of the word dictionary. `8b*E` for "me" is the same length.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 14 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
`èï`ri@°+T°
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=YInoG%2b%2bMYHJpQLArVLA&input=Mg)
## [Japt](https://github.com/ETHproductions/japt), 13 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
+`spooky{+2}´
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=K2BzcG9va3l7KzJ9tA&input=Mg)
[Answer]
# AWK, 21 bytes
```
$0=$0"spooky"$0+2"me"
```
[Try it online!](https://tio.run/##SyzP/v9fxcBWxUCpuCA/P7tSScVA20gpN1Xp/39DLiMuYy4TLlMA "AWK – Try It Online")
Substitutes the input for `(input)spooky(input+2)me`. As the new value of `$0` is not zero nor null, prints `$0`.
[Answer]
## [Lua](https://www.lua.org/), 39 bytes
```
w=io.write w(...)w'spooky'w(...+2)w'me'
```
Test
```
> lua -v & echo -------- & lua ./spooky.lua 2
Lua 5.4.0  Copyright (C) 1994-2020 Lua.org, PUC-Rio
--------
2spooky4me
```
[Answer]
## JAVA, 60 bytes
```
class p {String main(int n) {return n+"spooky"+(n+2)+"me";}}
```
Works fine on blueJ but not on TIO idk why?
[Answer]
# [tinylisp](https://github.com/dloscutoff/Esolangs/tree/master/tinylisp), 72 bytes
```
(load library
(q((N)(strcat(string N)(join2(q spooky)(q me)(string(a N 2
```
Anonymous function that takes a number and returns a name (tinylisp's equivalent of a string). [Try it online!](https://tio.run/##LYkxDoMwEAT7vGLLvS7wEBpecAlRdGB8xnbj1xuQqGY0Uy22YCX1zuC6INgna24vLph5kJOw1PzVesPiH1dY3eLIAyW5b00u23/yfComjJ27JszgUB3DW6Sf "tinylisp – Try It Online")
### Ungolfed/explanation
```
(load library)         ; Needed for strcat, join2, and ungolfed aliases
(lambda (N)            ; Anonymous function with one argument
  (strcat              ; Concatenate these two names as a single string:
    (string N)         ; Convert the input number to a string, and
    (join2             ; Join these strings together:
      (q spooky)       ;   "spooky" and
      (q me)           ;   "me", with the following separator:
      (string          ;   Convert to a string
        (add2 N 2))))) ;   the input number plus 2
```
[Answer]
# Python, 39 bytes
```
x=int(input());print(f"{x}spooky{x+2}me)
```
*Don't remove the `int()`. That will cause an error.
Tested on `Python 3.10.1 (v3.10.1:2cd268a3a9, Dec 6 2021, 14:28:59) [Clang 13.0.0 (clang-1300.0.29.3)] on darwin`*
[Answer]
# [BQN](https://mlochbaum.github.io/BQN/), ~~30~~ 28 bytes
```
•Fmt∾"spooky"∾"me"∾˜·•Fmt+⟜2
```
Anonymous tacit function. [Try it at BQN online](https://mlochbaum.github.io/BQN/try.html#code=RiDihpAg4oCiRm104oi+InNwb29reSLiiL4ibWUi4oi+y5zCt+KAokZtdCvin5wyCgpGwqgg4p+oMiwgNCwgOCwgOTnin6kK)
### Explanation
Reading right-to-left:
* `+⟜2` adds 2 to the argument
* `•Fmt` converts that number to a string
* `·` helps with parsing
* `"me"∾˜` concatenates `me` to the end of the string
* `"spooky"∾` concatenates `spooky` to the beginning of the string
* `•Fmt∾` concatenates the argument, stringified, to the beginning of the string
[Answer]
# [J](https://www.jsoftware.com), 24 bytes
```
'me',~":,'spooky',":@+&2
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m70wa8GCpaUlaboWN_XSFGytFNRzU9V16pSsdNSLC_LzsyvVdZSsHLTVjLhSkzPyFdLU7BTsrBQy9QwNILqgmmGGAAA)
If you've seen the BQN or APL golfs then you've seen this one.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 11 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
k╕o3╣Rk⌠ûme
```
[Try it online.](https://tio.run/##y00syUjPz0n7/z/70dSp@caPpi4Oyn7Us@Dw7tzU//8NuYy4LLkMDQwA)
**Explanation:**
```
k           # Push the input-integer
 ╕o3        # Push compressed string "spoo"
    ╣R      # Push compressed string "ky"
      k     # Push the input-integer again
       ⌠    # Increase it by 2
        ûme # Push string "me"
            # (after which the entire stack joined together is output implicitly)
```
`k...k⌠` could alternatively have been `└)...@` for the same byte-count: [try it online](https://tio.run/##AScA2P9tYXRoZ29sZv//4pSUKeKVlW8z4pWjUkDDu21l//8xCjIKOQoxMDA).
```
└           # Increase the (implicit) input-integer by 1 without popping
 )          # Pop and increase it by 1 again
       @    # Reverse triple-swap the top three values on the stack
```
[Answer]
# MATL, 18 bytes
```
'spooky'yUQQV'me'v
```
[Try it on MATL Online](https://matl.io/?code=%27spooky%27yUQQV%27me%27v&inputs=%272%27&version=20.9.1)
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `Ṫ`, 12 bytes
```
:⇧‛me«½↵*←«∇
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyLhuaoiLCIiLCI64oen4oCbbWXCq8K94oa1KuKGkMKr4oiHIiwiIiwiMiJd)
2spooky4joe
## Explained
```
:⇧‛me«½↵*←«∇
:⇧             # Without popping, push input + 2 - this leaves the stack as [input, input + 2]
  ‛me          # push the string "me"
     «½↵*←«    # and the string "spooky"
           ∇   # rotate the top three items and output the sum of the stack
```
[Answer]
# [><> (Fish)](https://esolangs.org/wiki/Fish), 26 bytes
```
:n'ykoops'oooooo2+n'em'oo;
```
[Try it](https://mousetail.github.io/Fish/#eyJ0ZXh0IjoiOm4neWtvb3BzJ29vb29vbzIrbidlbSdvbzsiLCJpbnB1dCI6IiIsInN0YWNrIjoiMyIsInN0YWNrX2Zvcm1hdCI6Im51bWJlcnMiLCJpbnB1dF9mb3JtYXQiOiJjaGFycyJ9)
]