Ya hice esto en Python, pero parece que podría acortarse mucho:

txt = input("Type something.. ")
c = "#"
b = " "
print(c * (len(txt) + 4))
print(c, b * len(txt), c)
print(c, txt, c)
print(c, b * len(txt), c)
print(c * (len(txt) + 4))

Entonces, si el usuario escribe:

Hello World

El programa imprime:

###############
#             #
# Hello World #
#             #
###############

CJam, 22 20 bytes

qa{4/3*' +f+W%z}8/N*

Pruébalo aquí.

Explicación

¿Cómo se ajusta una cuadrícula 2D de caracteres en una capa de espacios (o cualquier otro carácter)? Correcto: cuatro veces, agrega un espacio a cada línea y luego gira la cuadrícula 90 grados. Eso es exactamente lo que estoy haciendo aquí con ocho rotaciones: cuatro para espacios, cuatro para #:

qa      e# Read the input and wrap it in an array, to make it a 2D grid.
{       e# Execute this block for each value from 0 to 7.
  4/3*  e#   Divide by 4, multiply by 3. Gives 0 for the first four iterations and
        e#   and 3 for the other four.
  ' +   e#   Add the result to a space character (space + 3 == #).
  f+    e#   Append this to each line of the grid.
  W%z   e#   Reverse the lines, then transpose the grid - together these rotate it.
}8/
N*      e# Join the lines of the grid by newlines.

vim, 28 27 pulsaciones de teclas

I# <esc>A #<esc>Y4PVr#G.kwv$3hr kk.

Asume que la entrada se proporciona como una sola línea de texto en el archivo abierto actualmente.

Explicación:

I# <esc>        put a "#" and space at the beginning of the line
A #<esc>        put a space and "#" at the end of the line
Y4P             copy the line 4 times
Vr#             replace the entirety of the first line with "#"s
G.              do the same for the last line
kwv$3hr<space>  replace middle of the fourth line with spaces
kk.             do the same for the second line

Esto también se puede ejecutar como un "programa" así:

echo 'Hello World' | vim - '+exe "norm I# \<esc>A #\<esc>Y4PVr#G.kwv$3hr kk."'

Lo cual es un poco complicado, pero funciona.

pb - 89 bytes

v[4]w[Y!-1]{b[35]^}w[B!0]{t[B]vvv>>b[T]^^^<}v>>>w[Y!4]{b[35]v}w[X!0]{b[35]^[Y]b[35]v[4]<}

¡Este es el tipo de desafío para el que se hizo pb! No es que sea competitivo para este tipo de desafío ni nada. Sigue siendo un horrible lenguaje de golf. Sin embargo, desafíos como este son mucho menos difíciles de resolver en pb que otros. Dado que pb trata su salida como un lienzo 2D y puede escribir en cualquier coords, cualquier cosa que implique posicionar texto / dibujar alrededor del texto (es decir, este desafío) se maneja de manera bastante intuitiva.

Míralo correr:

esta visualización se creó con una versión en desarrollo de pbi, el intérprete de pb. La línea con el fondo azul es Y=-1, donde la entrada se almacena cuando se inicia el programa. El rectángulo con el fondo rojo es la ubicación actual del pincel. Los rectángulos con fondos amarillos están en cualquier lugar donde el carácter ascii 32 (un espacio) esté escrito explícitamente en el lienzo. Cualquier espacio en blanco sin este fondo en realidad tiene el valor 0, que se convierte en un espacio.

Aquí está el código con los comentarios que usé al escribirlo, con algunos encabezados de sección temáticamente relevantes;)

################################
#                              #
# Handle first column oddities #
#                              #
################################
v[4]           # Start from Y=4 and go up (so we land on input afterwords)
w[Y!-1]{       # While we're on the visible part of the canvas
    b[35]^         # Write "#", then go up
}

#########################
#                       #
# Insert text of output #
#                       #
#########################

w[B!0]{        # For each character of input
    t[B]           # Save input char in T
    vvv>>          # Down 3 + right 2 = where text part of output goes
    b[T]^^^<       # Write T and go to next char
}

###############################
#                             #
# Handle last column oddities #
#                             #
###############################

v>>>           # Go to Y=0, X=(X of last text output's location + 2)
w[Y!4]{        # Until we reach the last line of output
    b[35]v         # Draw "#", then go down
}

###########################
#                         #
# Loop to finish Y=0, Y=4 #
#                         #
###########################

w[X!0]{        # Until we've gone all the way left
    b[35]^[Y]      # Print "#" at Y=4, go to Y=0
    b[35]v[4]      # Print "#" at Y=0, go to Y=4
    <              # Move left, printing until output is complete
}

brainfuck - 156 bytes

++++++++++>,[>>+++++[<+++++++>-],]<....[.---<<]>>+++>>+++.---.[.>>]<<.+++.[<]>.>>+++.---.<[.>>]<<<.>>.---[<]>.--->>+++.---[.>>]<<..+++.---[<]>[+++.>>]<<....

Esto es probablemente golfable. Hay algunos lugares donde no sabía si sería mejor almacenar un valor en algún lugar para reutilizarlo o rehacerlo / ir a buscarlo a otra parte de la cinta. En lugar de hacer el trabajo para resolverlo, no hice eso. :RE

Con comentarios:

++++++++++>              Place a 10 (\n) at the beginning of the tape

,[>>+++++[<+++++++>-],]  Place a byte of input; place a 35 (#); repeat until end of input

<....                    Print the last cell (35; #) 4 times

[.---<<]                 Print every noninput cell on the tape in reverse (one # for each byte of input; then \n)
                         After printing each cell; decrease it by 32

>>+++                    Increase the 7 back up to 10

>>+++.---.               Increase a 32 (space) back up to 35 (#); print it; put it back to 32 and print again

[.>>]                    Print every 32 on the tape (one for each byte of input)

<<.+++.                  Print the last space again; increase it by 3 and print the resulting #

[<]>.                    Go to the beginning of the tape and print the \n

>>+++.---.               Increase a 32 (space) back up to 35 (#); print it; put it back to 32 and print again

<[.>>]                   Print every byte of input

<<<.>>.---               Print a space; then print a 35 (#} that was left behind earlier; Set it back to 32 after

[<]>.---                 Go to the beginning of the tape and print the \n; decrease by 3

>>+++.---                Set a space to #; print it; set it back to space

[.>>]                    Print all spaces

<<..+++.---              Print a space twice more; set it to #; print it again; set it back to space

[<]>                     Go to the "newline" (currently a 7 instead of 10)

[+++.>>]                 Increase by 3; print; do the same for all spaces (to set them to # before printing)

<<....                   Print the last # 4 more times

K, 21 bytes

4(|+"#",)/4(|+" ",)/,

Aliste la cadena, agregue un espacio a los cuatro lados de una cadena, luego agregue un octothorpe a cada lado de la cadena. En acción:

  4(|+"#",)/4(|+" ",)/,"Hello."
("##########"
 "#        #"
 "# Hello. #"
 "#        #"
 "##########")

Funciona en oK, Kona y k5.

Hay bastantes variaciones dentro de un carácter de longitud que eliminan la redundancia en lo anterior, pero ninguna parece romperse incluso cuando solo tenemos que realizar la operación de "ajuste" dos veces:

{x{|+x," #"y}/&4 4},:
{x{|+x,y}/,/4#'" #"},:
{x{|+x,y}/" #"@&4 4},:
{|+x,y}/[;" #"@&4 4],:

Pyth, 31 bytes

Js[K\#*d+2lzKb*K+4lz)_Jjd[KzK)J

Gracias a las personas en los comentarios que dan pistas sobre cómo jugar más al golf, realmente no conozco el idioma tan bien como (probablemente) se puede decir.

Python 3, 88 bytes

Gracias @WorldSEnder

s=" ";n=s+input()+s
b=len(n)
h="#";x=h*(b+2);y=h+s*b+h;z="\n"
print(x+z+y+z+h+n+h+z+y+z+x)

Ejemplo de E / S:

This is a test
##################
#                #
# This is a test #
#                #
##################

Perl, 43 76 bytes

Transforme cada línea de entrada de texto como se especifica:

s/.*/($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x"/e

Por ejemplo:

echo surround a long string with pounds | 
perl -ple's/.*/($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x"/e' 
######################################
#                                    #
# surround a long string with pounds #
#                                    #
######################################

Aquí le mostramos cómo ver realmente lo que está haciendo:

perl -MO=Deparse,-p,-q,-x9 -ple '($x=("#"x(4+($z=length))))."\n".($y="#"." "x(2+$z)."#\n")."# $& #\n$y$x";'
BEGIN { $/ = "\n"; $\ = "\n"; }
LINE: while (defined(($_ = <ARGV>))) {
    chomp($_);
    (((($x = ('#' x (4 + ($z = length($_))))) . "\n") . ($y = (('#' . (' ' x (2 + $z))) . "#\n"))) . (((('# ' . $&) . " #\n") . $y) . $x));
}
continue {
    (print($_) or die((('-p destination: ' . $!) . "\n")));
}
-e syntax OK

Entonces algo más como esto:

((  
      (($x =  ('#' x (4 + ($z = length($_))))) . "\n")
    .  ($y = (('#' . (' ' x (2 + $z))) . "#\n"))
  )  
    .  (((('# ' . $&) . " #\n") . $y) . $x)
)   

JavaScript (ES6), 73

Utilizando en gran medida la cadena de plantilla, las 2 nuevas líneas son significativas y contadas.

Pruebe a ejecutar el fragmento a continuación en cualquier navegador compatible con EcmaScript 6 (Firefox y el último Chrome, tal vez Safari).

f=s=>(z=c=>`*${c[0].repeat(s.length+2)}*
`)`*`+z` `+`* ${s} *
`+z` `+z`*`

// Less golfed

U=s=>(
  z=c=>'*' + c.repeat(s.length+2) + '*\n',
  z('*') + z(' ') + '* ' + s + ' *\n' + z(' ') + z('*')
)

// TEST

O.innerHTML=f('Hello world!')

<pre id=O></pre>

Esto es bastante más corto que mi primer intento, derivado de este otro desafío :

f=s=>(q=(c,b,z=c.repeat(b[0].length))=>[z,...b,z].map(r=>c+r+c))('*',q(' ',[s])).join`\n`

Pitón 2, 74

s='# %s #'%input()
n=len(s)
b='\n#'+' '*(n-2)+'#\n'
print'#'*n+b+s+b+'#'*n

Toma entrada en citas como "Hello World".

• La tercera línea es la entrada encerrada en # _ # .
• Las líneas segunda y cuarta b son# # el número correcto de espacios, rodeadas de líneas nuevas a cada lado para cuidar las cuatro líneas nuevas.
• Las líneas primera y quinta se #multiplican por la longitud de la entrada.

Las líneas se concatenan e imprimen.

MATLAB, 93 91 bytes

No es el más bonito, pero hace el trabajo.

t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])

Explicación del Código

Paso 1

t=[32 input('','s') 32];

Lea en una cadena de STDIN y coloque un espacio inicial y final dentro de él. 32 es el código ASCII para un espacio y la lectura en la entrada como un tipo de cadena fusiona los 32 en espacios.

Paso 2

m='#####'.';

Declare una matriz de caracteres de 5 signos hash en un vector de columna.

Paso 3

n=repmat('# ',numel(t),1)'

Cree una matriz de caracteres de 2 filas que se rellene con signos hash primero seguidos por espacios en blanco después. El número de caracteres es la longitud de la cadena de entrada más 2 para que podamos acomodar el espacio antes y después de la cadena.

Etapa 4

disp([m [n;t;flipud(n)] m])

Vamos a armar todo junto. Colocamos la primera columna de 5 hashes, seguida de la parte central y seguida de otra columna de 5 hashes. La parte central consiste en la matriz de caracteres de 2 filas creada en el Paso # 3, la cadena de entrada en sí que tiene un espacio inicial y final, seguida de la matriz de caracteres de 2 filas pero invertida.

Ejecuciones de ejemplo

>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
This is something special for you
#####################################
#                                   #
# This is something special for you #
#                                   #
#####################################
>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
Hello World
###############
#             #
# Hello World #
#             #
###############
>> t=[32 input('','s') 32];m='#####'.';n=repmat('# ',numel(t),1)';disp([m [n;t;flipud(n)] m])
I <3 Code Golf StackExchange!
#################################
#                               #
# I <3 Code Golf StackExchange! #
#                               #
#################################

Perl 5.14+, 57 56 bytes

perl -lpe '$_=join"#
#",($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'

54 bytes + 2 bytes para -lp(si la entrada no termina en una nueva línea, -lse puede descartar para guardar un byte).

Acepta entrada en STDIN:

$ echo Hello World | perl -lpe '$_=join"#
#",($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'
###############
#             #
# Hello World #
#             #
###############

Cómo funciona

El núcleo del programa es un segmento de lista:

($_=" $_ ",y// /cr,"#".y//#/cr)[2,1,0..2]'

Esto proporciona una forma compacta de almacenar las tres filas únicas de la salida (las dos primeras filas del cuadro delimitador son las mismas que las dos últimas, solo reflejadas). Para la cadena de entrada foo, los resultados del segmento serían:

index   value
--------------
  2    "######"
  1    "     "
  0    " foo "
  1    "     "
  2    "######"

Unir estos valores con #\n#nos da nuestra caja.

Tenga en cuenta que se requiere Perl 5.14+ para usar el rmodificador no destructivo para el operador de transliteración y///.

PHP 95 93 bytes

No es exactamente brillante ni nada similar, ¡pero en realidad fue divertido!

$l=strlen($s=" $argv[1] ");printf("#%'#{$l}s#
#%1\${$l}s#
#$s#
#%1\${$l}s#
#%1\$'#{$l}s#",'');

No es exactamente bonito ni nada, ¡pero funciona de manera brillante!

Gracias a @Titus por guardar 2 bytes.

C ++, 198 bytes

#include <iostream>
#include <string>
int i;int main(){std::string t,n,o;std::getline(std::cin,o);t="\n#";o="# "+o+" #";for(;i<o.size();i++){n+="#";if(i>1)t+=" ";}t+="#\n";std::cout<<n+t+o+t+n;}

Mi primer intento de codegolf, y aunque aprendí que C ++ probablemente no sea el mejor lenguaje para jugar golf, sentí que lo hice decentemente (?) En mi primer intento.

Sin golf

#include <iostream>
#include <string>

int i;                              //globals default to a value of 0

int main()
{
    std::string t, n, o;
    std::getline(std::cin, o);

    t = "\n#";                      // t needs hashes at start and end, places hash at start here
    o = "# " + o + " #";            // put hash at each end of input

    for(; i < o.size(); i++) {
        n += "#";                   // fills n with hashes
        if(i > 1) {
            t += " ";               // fill t with spaces between hashes, has two fewer spaces than n has hashes
        }
    }
    t += "#\n";                     // puts final hash at end of t

    std::cout << n + t + o + t + n; // final output
}

n, o y t representan las líneas con hash completo, la entrada (con hashes en cada extremo) y las líneas entre la entrada y las líneas con hash respectivamente.

> <> , 106104 Bytes

Tengo la sensación de que> <> puede no ser el mejor lenguaje para esto, pero he llegado demasiado lejos para rendirme y no publicar esto. Se *supone que el final de la línea 4 es un espacio. ¿No te encanta lo increíblemente grotesco que se ve este código? Pruébalo en línea .

<v?(0:i
v>~" ## "}}l:::
>"#"o1-:?!v02.>~a"#"oo
"-2ooa"#"~<.31v!?:-1o" 
7v?=3loroo"#"a<.4
.>";^"e3pa2p093

Aquí hay una versión sin nada más que cambiadores de dirección para dar una idea de cómo se mueve el puntero (tenga en cuenta que he omitido las declaraciones de "teletransporte", es decir .).

Flujo de dirección:

<v
v>
>         v   >
          <   v 
 v            <
 >           

Explicación

Mi visualización de la pila se basará en la entrada input. > <> es un lenguaje bidimensional, así que preste atención a dónde se mueve el puntero entre las líneas, ya que ejecuta el código debajo de él (en este código<>v^ se utilizan principalmente para cambiar de dirección). Comenzaré mis explicaciones desde donde comienza el puntero. Tenga en cuenta que habrá dos líneas repetidas, ya que el puntero se mueve hacia atrás después de la quinta línea.

Lo que siempre me gusta de> <> es su capacidad para modificar su propio código fuente, y lo uso en este programa. Las líneas 3 y 4 se reutilizan para imprimir las dos últimas líneas mediante una modificación de un carácter en cada una.

Línea 1: bucle de entrada

<v?(0:i
<        change direction to left
   (0:i  checks if input is less than 0 (no input defaults to -1)
 v?      change direction to down if so

Apilar: [-1,t,u,p,n,i]

Línea 2: genera la tercera línea de salida

v>~" ## "}}l:::  
 >~" ## "}}      remove -1 (default input value) from stack and pads with # and spaces
           l:::  push 4 lengths of padded input

Apilar: [9,9,9,9,#, ,t,u,p,n,i, ,#]

Línea 3: imprime la primera línea de salida

>"#"o1-:?!v02.>~a"#"oo
>"#"o                   print "#"
     1-                 subtract 1 from length (it's at the top of the stack)
       :?!v             move down if top of stack is 0

Apilar: [0,9,9,9,#, ,t,u,p,n,i, ,#]

Salida:

#########

Línea 4: imprime la segunda línea de salida

"-2ooa"#"~<.31v!?:-1o"*
 -2ooa"#"~<              pops 0, prints newline, "#", then decrements length by 2
"                   o"*  prints space (* is supposed to be space char)
                  -1     decrements top of stack
           .31v!?:       changes direction to down if top of stack is 0, else jumps back to "

Apilar: [0,9,9,#, ,t,u,p,n,i, ,#]

Salida ( *representa espacio):

#########
#*******

Línea 5: imprime la tercera línea de salida

7v?=3loroo"#"a<.4
        oo"#"a<    prints "#",newline
       r           reverses stack
7v?=3lo        .4  outputs until stack has 3 values, then changes direction to down

Apilar: [9,9,0]

Salida:

#########
#       #
# input #

Línea 6: se configura para imprimir la cuarta y quinta línea de salida

.>";^"e3pa2p093
 >";^"           push ";",then "^"
      e3p        place "^" as the fifteenth character on line 4
         a2p     place ";" as the eleventh character on line 3
            0    push a value (value doesn't matter -- it will be deleted)
.            93  jump to the tenth character on line 4

Apilar: [0,9,9,0]

Línea 4: imprime la cuarta línea de salida

"-2ooa"#"~<.31^!?:-1o"*
   ooa"#"~<              delete 0 (unnecessary value pushed), then print newline,"#"
 -2                      subtract two from value on top of stack (length)
"          .31^!?:-1o"*  print space until top of stack is 0, then change direction to up

Apilar: [0,9,0]

Salida ( *representa espacio):

#########
#       #
# input #
#*******

Línea 3: imprimir la última línea de salida

"#"o1-:?!;02.>~a"#"oo
             >~a"#"oo  pop top of stack, print "#", newline
"#"o1-:?!;02.          print "#" until top of stack is 0, then terminate

Apilar: [0,0]

Salida:

#########
#       #
# input #
#       #
#########

PHP, 93 91 bytes

$b=str_pad("",$e=strlen($s=" $argv[1] "));echo$h=str_pad("",2+$e,"#"),"
#$b#
#$s#
#$b#
$h";

Toma información del argumento de la línea de comando; escapar de espacios o usar comillas simples. Corre con -r.

Pyke (no competitivo), 6 bytes

.X".X#

Pruébalo aquí!

Pyke fue escrito después del desafío y, por lo tanto, no es competitivo.

.X"    - surround string in spaces
   .X# - surround string in hashes

.Xtoma una cadena y una cadena constante arg y rodea una cadena con ese grupo de caracteres. El argumento constante puede tener hasta 8 caracteres y tener diferentes efectos sobre cómo se rodea la cadena.

05AB1E, 26 bytes , no compite

g4+'#ש,¹' .ø'#.ø,®,

Pruébalo en línea!

EDITAR: Woah! ¡No me di cuenta de que este es un viejo desafío! ¡Lo siento!

C # - 142 bytes (el cuerpo del método es 104)

class P{static void Main(string[]a){for(int i=0;++i<6;)System.Console.Write("#{0}#\n",i==3?$" {a[0]} ":new string(" #"[i%2],a[0].Length+2));}}

Sin golf:

class P
{
    static void Main(string[] a)
    {
        for (int i = 0; ++i < 6;)
            System.Console.Write("#{0}#\n", i == 3 ? $" {a[0]} " : new string(" #"[i%2], a[0].Length + 2));
    }
}

PowerShell, 84 82 bytes

$l=$input.length+4;$p='#'*$l;$s=' '*$l;$p,$s,"  $input  ",$s,$p-replace'^ | $','#'

Lua, 90 bytes

a=arg[1]h="#"s=" "t="\n"..h c=h:rep(#a+4)..t..s:rep(#a+2)..h..t..s print(c..a..c:reverse())

Ruby, 83 bytes

Supongo que podría jugarse más, pero como todavía no hay una respuesta de Ruby, aquí está:

s=ARGV[0]
n=s.size
r="#"*(n+4)
t="\n#"+" "*(n+2)+"#\n"
puts r+t+"\n# "+s+" #\n"+t+r

Raqueta 172 bytes

(λ(s)(let((n(string-length s))(p #\space)(g(λ(l c)(make-string l c))))(display(string-append
(g(+ 4 n)#\#)"\n#"(g(+ 2 n)p)"#\n# "s" #\n#"(g(+ 2 n)p)"#\n"(g(+ 4 n)#\#)))))

Sin golf:

(define (f s)
  (let ((n (string-length s))
        (p #\space)
        (g (λ (l c) (make-string l c))))
    (display (string-append (g (+ 4 n) #\#)
                            "\n#"
                            (g (+ 2 n) p)
                            "#\n# "
                            s
                            " #\n#"
                            (g (+ 2 n) p)
                            "#\n"
                            (g (+ 4 n) #\#)
                            ))))

Pruebas:

(f "This is a test" )

Salida:

##################
#                #
# This is a test #
#                #
##################

C #, 116 110 bytes

s=>{string r="\n".PadLeft(s.Length+5,'#'),p="#".PadRight(s.Length+3,' ')+"#\n";return r+p+"# "+s+" #\n"+p+r;};

Sin golf:

s=>
{
    string r = "\n".PadLeft(s.Length + 5, '#'),         //the first line, made of '#'s
        p = "#".PadRight(s.Length + 3, ' ') + "#\n";    //the second line
    return r + p + "# " + s + " #\n" + p + r;           //output is simmetrical
};

Versión inicial:

s=>{int l=s.Length;string r=new string('#',l+4)+"\n",p="#"+new string(' ',l+2)+"#\n";return r+p+"# "+s+" #\n"+p+r;};

Programa completo con casos de prueba:

using System;

namespace SurroundStringWithHashes
{
    class Program
    {
        static void Main(string[] args)
        {
            Func<string,string>f= s=>{int l=s.Length;string r=new string('#',l+4)+"\n",p="#"+new string(' ',l+2)+"#\n";return r+p+"# "+s+" #\n"+p+r;};

            Console.WriteLine(f("Hello World"));
            Console.WriteLine(f("Programming Puzzles & Code Golf"));
        }
    }
}

C (gcc) 165 bytes

f(*s){i,j;c='#';for(j=0;j<5;j++){if(j==0||j==4){for(i=0;i<strlen(s)+2;i++)printf("#");}else if(j==2) printf("#%s#",s);else printf("#%*c",(strlen(s)+1),c);puts("");

Versión sin golf

void  f(char *s)
{
    int i,j;
    char c='#';

    for(j=0;j<5;j++)
    { 
       if(j==0||j==4)
       { 
         for(i=0;i<strlen(s)+2;i++)
           printf("#");
       }
       else
        if(j==2)
         printf("#%s#",s);
      else
        printf("#%*c",(int)(strlen(s)+1),c);

   puts("");
}

SmileBASIC, 73 bytes

LINPUT S$L=LEN(S$)+2O$="#"+" "*L+"#
T$="#"*(L+2)?T$?O$?"# ";S$;" #
?O$?T$