Svogliati
🦾

ARMper Svogliati

Per trent'anni il mondo era diviso in due: i computer avevano Intel o AMD, i telefoni avevano ARM. Poi Apple ha messo un processore da telefono nei Mac ed è andato più veloce, Amazon ha messo i suoi nei server, e il Raspberry sul tuo scaffale ce l'aveva già. Oggi la domanda "ARM o x86?" te la fa anche il pannello del cloud. Ecco cosa cambia davvero, e cosa si rompe se scegli quello sbagliato.

"Ho preso il server ARM che costava meno." — "E l'immagine Docker?" — "exec format error."

↓
01 / 15

Cos'è ARM, e cosa non è

Arm non fabbrica processori. Vende il progetto, e la licenza per usarlo. È la differenza da cui discende tutto il resto.

Intel progetta i suoi processori e (in gran parte) li fabbrica; AMD li progetta e li fa fabbricare. Si vendono chip finiti. Arm, un'azienda inglese di Cambridge, non vende chip: vende due cose diverse. La licenza dell'architettura, cioè il diritto di costruire un processore che capisce le istruzioni ARM, progettandolo da zero (è quello che fa Apple). Oppure i progetti dei core già pronti (Cortex per telefoni e Raspberry, Neoverse per i server), che un'azienda mette nel suo chip insieme ad altro e fa produrre da TSMC o Samsung.

📜

Un'architettura

Il "linguaggio" del processore: quali istruzioni esistono e come si scrivono. ARMv8 e ARMv9 a 64 bit sono quelle di oggi.

🏭

Tanti costruttori

Apple, Qualcomm, Amazon, Google, Microsoft, NVIDIA, Ampere, Broadcom (quella del Raspberry), MediaTek, Samsung. Ognuno fa il suo chip.

🔋

Nato per consumare poco

Trent'anni di telefoni e dispositivi a batteria: l'efficienza è nel DNA. Le prestazioni sono arrivate dopo.

🏷️ Un nome, quattro scrittureLo stesso ARM a 64 bit si chiama aarch64 per il kernel Linux e per uname, arm64 per Debian, Docker, Go e macOS, ARMv8 o ARMv9 quando si parla di architettura. È sempre la stessa cosa. L'ARM a 32 bit, quello dei Raspberry vecchi, si chiama invece armhf o armv7, ed è un altro mondo.
02 / 15

Da un computer per le scuole inglesi a metà del cloud

Quarant'anni di storia, quasi tutti passati nell'ombra, dentro oggetti che nessuno apriva.

1985

Acorn RISC Machine

Acorn, che faceva computer per le scuole britanniche, progetta il suo processore: semplice, poche istruzioni, pochi transistor. Il primo esemplare funziona al primo colpo, e consuma così poco che, si racconta, funzionava anche con l'alimentazione staccata, grazie alla corrente che arrivava dai circuiti di prova.

1990

Nasce Arm, con Apple tra i soci

Acorn, Apple e VLSI fondano Advanced RISC Machines. Apple cerca un processore per il Newton, un'agenda elettronica che sarà un flop. Arm decide di non fabbricare niente e di vivere di licenze.

Anni '90–2000

Dentro tutto, senza che nessuno lo sappia

Telefoni Nokia, Game Boy Advance, iPod, router, stampanti, hard disk. Miliardi di chip all'anno, e il nome lo conoscono solo gli ingegneri.

2007–2012

Smartphone e Raspberry Pi

iPhone, poi Android: ogni smartphone è ARM. Nel 2012 il Raspberry Pi mette un ARM con Linux nelle mani di milioni di studenti e smanettoni. Microsoft prova Windows su ARM con Windows RT: fallimento.

2016–2023

SoftBank, il tentativo di NVIDIA, il ritorno in Borsa

Il gruppo giapponese SoftBank compra Arm. Nel 2020 NVIDIA prova a comprarla per 40 miliardi: le autorità antitrust di mezzo mondo si mettono di traverso e l'accordo salta nel 2022. Nel 2023 Arm torna in Borsa, con SoftBank azionista di maggioranza.

2018–2020

I server e il Mac

Amazon presenta Graviton, il suo processore ARM per il cloud. Nel 2020 il supercomputer più potente del mondo è giapponese e ARM (Fugaku). A novembre Apple lancia il Mac con M1: più veloce degli Intel che sostituisce, con il doppio dell'autonomia. È il momento in cui tutti capiscono.

2024–2026

Tutti i grandi cloud hanno il loro ARM

Google con Axion, Microsoft con Cobalt, Amazon arriva a Graviton5 con 192 core. I PC Windows con Snapdragon X tornano a provarci, questa volta sul serio. SoftBank compra anche Ampere, l'azienda che vende CPU ARM per server a tutti gli altri. Apple annuncia che dopo macOS 27 Rosetta 2, il traduttore per le vecchie app Intel, resterà solo per alcuni giochi.

03 / 15

ARM contro x86, oggi

"RISC contro CISC" è la risposta da manuale, e conta molto meno di quanto si dice. Le differenze vere sono altre.

Una volta la distinzione era netta: ARM è RISC (poche istruzioni semplici), x86 è CISC (tante istruzioni complesse). Oggi i processori x86 traducono internamente le loro istruzioni complesse in operazioni semplici, e quelli ARM hanno istruzioni tutt'altro che poche. La filosofia ha lasciato il segno, ma non è più quella la ragione per cui un Mac M4 consuma meno di un portatile Intel.

Dove cambia davveroARMx86 (Intel, AMD)
Modello di businessChiunque prenda la licenza può fare il suo chip, su misuraDue aziende, chip uguali per tutti
ConsumoProgettato da sempre per la batteria: ottimo rapporto prestazioni/wattMigliorato molto, ma parte da un'eredità desktop
vCPU nel cloudDi solito un core fisico intero per ogni vCPU (niente hyperthreading)Spesso una vCPU è metà core: un thread su due
CompatibilitàTutto il software va compilato per ARMQuarant'anni di programmi che funzionano e basta
Istruzioni vettorialiNEON, SVESSE, AVX, AVX-512: il software ottimizzato a mano spesso c'è solo per queste
Core diversi nello stesso chipNormale da anni (core veloci + core efficienti)Arrivato più tardi (Intel dal 2021)
⚖️ Il vantaggio di Apple non è solo ARMIl Mac con M1 era veloce anche perché Apple controlla tutto: chip, memoria saldata accanto al processore, sistema operativo, compilatori. Un portatile Windows con un ARM non diventa automaticamente un MacBook. Viceversa, gli ultimi AMD e Intel per portatili hanno ridotto molto la distanza sui consumi.
04 / 15

Il concetto chiave: il programma parla una lingua sola

Un programma compilato è scritto nella lingua di un processore. Se il processore parla un'altra lingua, non lo capisce. Punto.

📖 L'analogia: il libro tradotto

Il codice sorgente è il manoscritto dell'autore; il programma compilato è il libro tradotto in una lingua. Un libro in inglese (x86) non lo legge chi parla solo giapponese (ARM). Hai tre strade: far tradurre il manoscritto anche in giapponese (ricompilare per ARM, la soluzione vera), dare al lettore un interprete che traduce mentre legge (emulazione: funziona, ma più lento), oppure comprare un'edizione con dentro tutte e due le lingue (le immagini multi-architettura e i binari universali).

REGOLA 1

Linguaggi interpretati: quasi gratis

Python, PHP, Node.js, Java, Ruby: il tuo codice gira uguale. Serve solo che l'interprete e le estensioni compilate esistano per ARM. Ormai quasi sempre è così.

REGOLA 2

Linguaggi compilati: si ricompila

C, C++, Go, Rust: il codice di solito è portabile, il binario no. Con i sorgenti, ricompilare è facile. Senza sorgenti (software proprietario), dipendi dal produttore.

REGOLA 3

Controlla le dipendenze, non il tuo codice

Quasi mai è il tuo programma a non funzionare: è un'immagine Docker solo x86, un agente di monitoraggio, un driver, una libreria chiusa. È lì che va fatto l'inventario.

05 / 15

Chi fa processori ARM, e dove li trovi

Dal Raspberry sullo scaffale ai supercomputer, passando per il tuo Mac.

DoveChiNote
MacApple (serie M)Core progettati da Apple su licenza dell'architettura. Dal 2020 tutti i Mac nuovi
PC WindowsQualcomm Snapdragon XDal 2024. Le app x86 girano tramite Prism, l'emulatore di Windows. Con Arm c'è una lunga causa sulle licenze, finora favorevole a Qualcomm
Raspberry PiBroadcom, con core Cortex di ArmPi 3, 4 e 5 sono a 64 bit; usa il sistema a 64 bit se puoi (vedi Raspberry Pi per Svogliati)
Telefoni e tabletApple, Qualcomm, MediaTek, Samsung, GoogleTutti, da vent'anni
Server cloudAmazon, Google, Microsoft (per sé); Ampere (per tutti)Sezione 6
IA e supercomputerNVIDIA Grace, FujitsuGrace sta accanto alle GPU NVIDIA nei grandi sistemi di IA
🌱 E RISC-V?È l'alternativa aperta: un'architettura che chiunque può usare senza licenza, nata all'università di Berkeley nel 2010. Oggi è nei microcontrollori, nei dischi, in schede tipo Raspberry e nei chip dove non si vuole pagare Arm. Sui server e sui PC è ancora agli inizi. Per Arm è la concorrenza che fa più paura: lo stesso modello di business, senza il pedaggio.
06 / 15

I server ARM nel cloud

I grandi cloud se li fanno in casa; gli altri comprano da Ampere. In tutti i casi, il pannello ti chiede di scegliere l'architettura.

FornitoreProcessoreCosa sapere
AWSGraviton (dal 2018), oggi Graviton4 e Graviton5Il più maturo. Le istanze con la "g" nel nome (m8g, c8g, r8g…). Graviton5 arriva a 192 core per chip
Google CloudAxionSu core Neoverse di Arm, istanze C4A e N4A
Microsoft AzureCobalt 100, poi Cobalt 200Microsoft lo usa anche per i propri servizi
Oracle CloudAmpereFamoso per il piano gratuito "Always Free" con macchine ARM: da giugno 2026 ridotto a 2 core e 12 GB
HetznerAmpere Altra (serie CAX)Solo in Germania e Finlandia. Sezione 7 per i prezzi
AmpereAltra, AmpereOneVende CPU ARM per server a chi non se le fa da solo. Dal novembre 2025 è di SoftBank, come Arm
🧱 Graviton, Axion e Cobalt sono "in casa"Non li puoi comprare: esistono solo nel cloud del loro produttore. Se vuoi un server ARM fisico in un tuo rack, la strada è Ampere (in server di vari marchi) o, per giocare, un Raspberry o un mini PC ARM.
07 / 15

Conviene davvero?

"ARM costa meno" è stato vero per anni. Oggi dipende dal fornitore, e va controllato ogni volta.

Un esempio concreto: i prezzi di Hetzner (Germania e Finlandia, IVA e IPv4 esclusi) dopo i due rincari del 2026, verificati a fine ottobre:

ServerArchitetturavCPURAMDiscoAl mese
CX23x86 (Intel/AMD condiviso)24 GB40 GB5,49 €
CAX11ARM (Ampere)24 GB40 GB5,99 €
CX33x8648 GB80 GB8,49 €
CAX21ARM48 GB80 GB10,49 €

Fino a inizio 2026 la CAX11 costava meno della CX equivalente; oggi costa un po' di più. Il vantaggio rimasto è un altro: una vCPU ARM è un core intero, una vCPU x86 condivisa spesso è un thread su un core diviso con altri. Sotto carico continuo, la CAX regge meglio. Negli hyperscaler (AWS, Google, Azure) invece le istanze ARM restano di solito più economiche delle x86 equivalenti, e i fornitori dichiarano un rapporto prezzo/prestazioni migliore del 20–40%: dichiarazioni loro, da misurare sul tuo carico.

ARM va benissimo per

  • Server web, reverse proxy, PHP, Node, Python, Go, Java
  • Container e Kubernetes, se le immagini sono multi-architettura
  • Database open source: PostgreSQL, MariaDB, Redis
  • Compilazione e CI: tanti core veri a buon prezzo
  • Tutto quello che gira 24 ore su 24 e consuma

Meglio x86 se

  • Usi software proprietario disponibile solo per x86
  • Ti serve Windows Server o un'applicazione Windows
  • Hai codice ottimizzato con AVX (alcuni calcoli scientifici, codec video)
  • Hai un agente o un driver di un fornitore che non lo supporta
  • Il server costa poco e il tempo per migrarlo costa di più
08 / 15

Cosa si rompe passando ad ARM

Il 95% funziona e basta. Il 5% è sempre lo stesso elenco di trappole.

TrappolaCosa succedeRimedio
Immagini Docker solo amd64Il container non parte, o parte in emulazione lentissimaCerca il tag multi-architettura, o costruisci l'immagine per arm64 (sezione 9)
Binari scaricati a manoLo script d'installazione scarica la versione x86_64Scarica la versione arm64/aarch64; correggi gli script che hanno amd64 scritto dentro
Pacchetti .deb di terze partiIl repository del fornitore ha solo amd64Chiedi al fornitore, o cerca un'alternativa nei repository della distribuzione
Estensioni compilate (Python, Node, PHP)pip o npm provano a compilare e fallisconoInstalla compilatore e header (build-essential, python3-dev), o aggiorna la libreria: le versioni recenti hanno i pacchetti pronti per arm64
Istruzioni troppo nuoveUn programma compilato per ARMv8.2 su un processore ARMv8.0 (come il Pi 4) muore con Illegal instruction. Esempio famoso: MongoDB dalla 5.0 sul RaspberryUna versione compilata per il processore più vecchio, o hardware più recente
Pagine di memoria da 16 o 64 KBAlcuni sistemi ARM (Asahi Linux sui Mac, alcuni kernel per server) usano pagine più grandi dei soliti 4 KB; programmi che lo danno per scontato si romponogetconf PAGESIZE per sapere com'è; per i server, un kernel con pagine da 4 KB evita sorprese
Bug nascosti nel codice CCodice che funzionava "per caso" su x86: char che su ARM è senza segno, accessi alla memoria tra thread senza sincronizzazione correttaSono bug veri, x86 li nascondeva. Si correggono nel codice
09 / 15

Docker multi-architettura

Un nome di immagine, più versioni dentro: Docker scarica da solo quella giusta per il processore. Quando c'è.

Un'immagine come nginx:latest in realtà è un indice (manifest list) che punta a una versione per ogni architettura. Quando fai docker pull, Docker sceglie quella del tuo processore. Le immagini ufficiali e quelle dei grandi progetti hanno quasi tutte arm64; quelle fatte da un singolo sviluppatore, o vecchie, spesso no.

bash · capire e costruire immagini multi-architettura
# per quali architetture esiste un'immagine?
docker manifest inspect nginx:latest | grep -A2 '"platform"'

# di che architettura è l'immagine che ho scaricato?
docker image inspect --format '{{.Os}}/{{.Architecture}}' nginx:latest

# forzare un'architettura diversa (girerà in emulazione)
docker run --platform linux/amd64 --rm alpine uname -m

# costruire la tua immagine per entrambe e pubblicarla con un nome solo
docker buildx create --use
docker buildx build --platform linux/amd64,linux/arm64 -t utente/app:1.0 --push .
🐢 Il build multi-architettura in emulazione è lentoSu una macchina x86, buildx costruisce la parte arm64 in emulazione con QEMU: un'immagine che compila molto può metterci cinque o dieci volte di più. Le alternative: un runner CI su ARM (molti servizi li offrono), un builder remoto su una macchina ARM, o la cross-compilazione dentro il Dockerfile (sezione 10).

Il resto del mondo Docker, dai volumi alla rete, è in Docker per Svogliati.

10 / 15

Compilare per ARM da x86, e viceversa

Cross-compilare: costruire sul tuo computer un programma per un processore diverso. Più facile di quanto sembri, con i linguaggi moderni.

bash · cross-compilazione
# Go: due variabili e basta
GOOS=linux GOARCH=arm64 go build -o app-arm64
GOOS=linux GOARCH=amd64 go build -o app-amd64

# Rust: il target, e cargo-zigbuild usa zig come linker (niente toolchain da installare)
rustup target add aarch64-unknown-linux-gnu
cargo zigbuild --release --target aarch64-unknown-linux-gnu

# C su Debian: il compilatore incrociato
sudo apt install gcc-aarch64-linux-gnu
aarch64-linux-gnu-gcc -O2 -o prog prog.c

# macOS: un "binario universale" con dentro sia ARM sia Intel
lipo -create -output app app-arm64 app-x86_64
lipo -info app         # Architectures in the fat file: x86_64 arm64
🔁 Funziona anche al contrarioDal Mac con chip M si compila tranquillamente per i server Linux x86: per esempio, un programma Rust per Linux x86_64 compilato sul Mac con cargo zigbuild, con la versione minima di glibc scelta apposta per farlo girare anche su distribuzioni vecchie. Il Mac è ARM, il server è x86, nessuno dei due se ne accorge.

Su Debian e derivate, il multiarch permette di installare librerie di un'altra architettura accanto alle tue (dpkg --add-architecture arm64), utile per compilare programmi che le richiedono. Il funzionamento dei pacchetti è in Pacchetti .deb per Svogliati.

11 / 15

L'emulazione: far girare x86 su ARM

Quando non puoi ricompilare, puoi tradurre. Ogni sistema ha il suo traduttore, e ognuno ha i suoi limiti.

TraduttoreDoveQuanto è buono
Rosetta 2macOS su chip MMolto: traduce le app Intel quasi senza che te ne accorga. Apple ha annunciato che dopo macOS 27 resterà solo per alcuni giochi: le app Intel vanno aggiornate
PrismWindows 11 su ARMBuono per le app normali, meno per giochi e programmi con driver. Le app ARM native girano molto meglio
QEMU user + binfmtLinuxFa girare singoli programmi di un'altra architettura, anche dentro Docker. Lento (da 5 a 20 volte), ma va bene per un build o un test
box64, FEXLinux su ARMTraduzione più veloce di QEMU per programmi x86_64, anche giochi. Usati sui Raspberry e sui portatili ARM con Linux
bash · far girare container x86 su un server ARM (o il contrario)
# registra gli emulatori QEMU nel kernel (binfmt_misc), una volta
docker run --privileged --rm tonistiigi/binfmt --install all

# ora un container amd64 parte anche su arm64, in emulazione
docker run --platform linux/amd64 --rm debian:stable uname -m     # x86_64
🪤 L'emulazione in produzione è una trappolaVa bene per costruire un'immagine, per provare un programma, per quell'unico strumento x86 che usi una volta al mese. Un servizio importante in emulazione, sul server ARM che hai preso per risparmiare, consuma il doppio della CPU e ha tempi di risposta peggiori: hai pagato di meno per avere di meno. Se un componente esiste solo per x86, quel componente va su una macchina x86.
12 / 15

Migrare un server su ARM, passo per passo

Non si migra "il server". Si verifica ogni pezzo, si prova su una macchina gemella, e si misura.

Passo 1

L'inventario

Tutto quello che gira: pacchetti della distribuzione (di solito nessun problema), repository di terze parti, binari scaricati a mano in /usr/local/bin e /opt, immagini Docker, agenti di monitoraggio e backup, script che scaricano qualcosa.

Passo 2

La verifica, componente per componente

Per ognuno: esiste per arm64? Pacchetti della distribuzione: sì. Immagini: docker manifest inspect. Binari e repository esterni: la pagina dei download del fornitore. Segna i "no" e decidi cosa fare per ognuno.

Passo 3

Un server di prova

Una macchina ARM piccola, pagata a ore, con la stessa distribuzione. Installa con gli stessi script o la stessa configurazione Ansible: è anche il modo di scoprire cosa non era scritto da nessuna parte.

Passo 4

La misura

Stessi test sulle due macchine: tempi di risposta, CPU sotto carico, durata di un backup o di un build. Il prezzo ha senso solo diviso per quello che il server fa.

Passo 5

Il passaggio, e la porta aperta

Sposta i dati, cambia il DNS, tieni il vecchio server spento ma esistente per qualche giorno. Se qualcosa non va, torni indietro in cinque minuti.

🧭 Non serve scegliere una volta per tutteSi possono avere server ARM e x86 insieme: i servizi web e i container sugli ARM, quel software proprietario sull'unico x86. Kubernetes e Docker gestiscono nodi di architetture diverse nello stesso cluster, a patto che le immagini siano multi-architettura.
13 / 15

Errori tradotti

Quando l'architettura è sbagliata, i messaggi sono sempre questi. Nessuno dice "architettura sbagliata".

Cosa vediCosa vuol direCosa fare
exec format errorIl file è un programma per un altro processorefile nomeprogramma ti dice per quale; scarica la versione giusta o usa l'emulazione
cannot execute binary file: Exec format errorLo stesso, detto da bashIdem
no matching manifest for linux/arm64/v8 in the manifest list entriesL'immagine Docker non esiste per ARMCerca un'immagine alternativa o costruiscila; in emergenza --platform linux/amd64
The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8)Docker sta per far girare l'immagine in emulazioneFunzionerà, ma lento: cerca la versione arm64
package architecture (amd64) does not match system (arm64)Stai installando un .deb per x86Scarica il .deb per arm64
Illegal instruction (core dumped)Il programma usa istruzioni che il tuo processore non ha (troppo vecchio, o compilato per uno più nuovo)Una versione compilata per un processore più vecchio
Unsupported system page sizeUn programma (spesso tramite jemalloc) non sopporta le pagine da 16 o 64 KBKernel con pagine da 4 KB, o una versione del programma ricompilata
No such file or directory su un file che c'èSpesso manca il "loader" dell'architettura giusta: il file c'è, l'interprete per lanciarlo nofile sul programma: probabilmente è di un'altra architettura
error: command 'gcc' failed durante pip installNon c'è un pacchetto già compilato per arm64, e pip prova a compilarloInstalla build-essential e gli header, o aggiorna la libreria
14 / 15

I comandi per capire su cosa sei

Prima di scaricare qualsiasi cosa, sapere che architettura hai e che architettura ha il file.

bash · Linux
uname -m                    # aarch64 = ARM 64 bit, x86_64 = Intel/AMD, armv7l = ARM 32 bit
dpkg --print-architecture   # arm64, amd64, armhf (i nomi di Debian)
lscpu                       # modello, core, e se è Neoverse, Cortex o altro
grep -m1 Features /proc/cpuinfo   # le estensioni del processore (asimd, sve…)
getconf PAGESIZE            # 4096 di solito; 16384 o 65536 su alcuni sistemi ARM
file /usr/local/bin/qualcosa   # "ELF 64-bit LSB executable, ARM aarch64" oppure "x86-64"
bash · macOS
uname -m                    # arm64 su chip M, x86_64 su Intel (o sotto Rosetta!)
sysctl -n machdep.cpu.brand_string   # "Apple M4" e simili
lipo -archs /Applications/Firefox.app/Contents/MacOS/firefox   # x86_64 arm64 = universale
arch -x86_64 /bin/bash      # una shell in modalità Intel, tramite Rosetta
🕵️ Le app che girano ancora sotto RosettaSu macOS, in Monitoraggio Attività aggiungi la colonna "Tipo": le app con "Intel" girano tradotte. Da macOS 26.4 il sistema avvisa anche da solo per le app che smetteranno di funzionare quando Rosetta verrà ridotta. È il momento di cercarne la versione Apple Silicon.
15 / 15

Cheat sheet

Quando scegliere ARM, e i nomi da non confondere.

SituazioneScelta
Server web, API, container con immagini multi-archARM, se il prezzo è uguale o migliore
Carico continuo su poche vCPUARM: core veri, non thread condivisi
Software proprietario solo x86, Windows Serverx86
Un componente su dieci solo x86ARM per gli altri nove, una macchina x86 per quello. Non emularlo
Compilazione e CIARM con tanti core, o tutte e due se rilasci per entrambe
Portatile per sviluppareMac con chip M: ottimo, se i tuoi server sono Linux e usi container multi-arch
NomeCos'è
aarch64 = arm64ARM a 64 bit (kernel e uname contro Debian, Docker, macOS)
armhf, armv7lARM a 32 bit: Raspberry vecchi e sistemi a 32 bit
x86_64 = amd64Intel e AMD a 64 bit
linux/arm64/v8Il nome della piattaforma per Docker
Cortex, NeoverseI core progettati da Arm: per dispositivi e per server
Graviton, Axion, Cobalt, Altra, M4, Snapdragon XI chip dei vari costruttori
🦾 L'ultimo consiglio da svogliatoPrima di cambiare architettura, fai l'inventario di quello che non è tuo: immagini, binari, agenti. Se tutto esiste per arm64, provare costa un'ora e pochi centesimi su una macchina a ore. Se qualcosa manca, non emularlo per risparmiare due euro al mese: tienilo su x86 e passa ad ARM tutto il resto.