UHJlcGFyYXRpIGFsbCdpbXBhdHRvOiB1bmEgZ3VpZGEgYWxsYSBuYXZpZ2F6aW9uZSBkaSB1biBjcm9sbG8gZGVsbGUgY3JpcHRvdmFsdXRlIG5lbCAyMDIz

<p><img src="https://gimg2.gateimg.com/blog/167117863874302594520221216-161657.jpeg" alt=""></p>
<p><strong>[TL; DR]</strong><br>🔹 Una caduta cripto si verifica quando il prezzo di una criptovaluta scende del 10% o più entro 24 ore.</p>
<p>🔹 <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Bitcoin</a> e altre criptovalute hanno subito molti crolli prima del 2022.</p>
<p>🔹 Nel 2022, la guerra in Ucraina, FUD, l’aumento dei tassi di interesse, la limitata liquidità e la manipolazione del mercato sono state cause contributive dei crolli delle criptovalute.</p>
<p>🔹 Le cose chiave da fare durante un crollo criptato includono mantenere la calma, tenere la propria criptovaluta e mantenere una prospettiva di investimento a lungo termine.</p>
<p><strong>Introduzione</strong><br>Il 2022 è stato il peggiore anno nella storia delle criptovalute a causa di diversi gravi crolli del mercato crittografico. L’anno è iniziato male a causa dell’aumento dell’inflazione in molti paesi del mondo, compresi gli Stati Uniti. In risposta, alcuni paesi hanno dovuto aumentare i tassi di interesse nel tentativo di frenare l’inflazione in aumento. La correlazione tra criptovalute e mercato azionario significa che gli effetti della volatilità del mercato azionario influenzano anche il mercato delle criptovalute.</p>
<h2 id="h2-Cause20dei20crolli20delle20criptovalute20nel202022632126"><a name="Cause dei crolli delle criptovalute nel 2022" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cause dei crolli delle criptovalute nel 2022</h2><p>Non vi è alcun dubbio che il 2022 abbia avuto gravi crolli di mercato che hanno ridotto la fiducia che le persone hanno nelle criptovalute. Le cause dei crolli del mercato delle criptovalute sono molte e diverse di esse si sono verificate nel 2022. Alcuni di questi sono fattori macroeconomici come l’aumento dell’inflazione, l’invasione della Russia dell’Ucraina, la correlazione tra il mercato azionario e le criptovalute e la manipolazione di mercato.</p>
<p>Per cominciare, cerchiamo di capire cos’è un crollo delle criptovalute. Un crollo delle criptovalute è una diminuzione brusca e improvvisa del prezzo di una criptovaluta. Fondamentalmente, si riferisce a una caduta del 10% o più del prezzo di una criptovaluta entro 24 ore. Le principali cause del crollo delle criptovalute includono notizie che influenzano le condizioni economiche e altri importanti sviluppi globali negativi come scoppio di guerre o pandemie.</p>
<h2 id="h2-Correlazione20tra20il20mercato20azionario20e20il20mercato20delle20criptovalute940915"><a name="Correlazione tra il mercato azionario e il mercato delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Correlazione tra il mercato azionario e il mercato delle criptovalute</h2><p>Il mercato delle criptovalute è correlato al mercato azionario. Di conseguenza, qualsiasi tendenza al ribasso che si verifica nel mercato azionario è probabile che si riversi sul mercato delle criptovalute. Infatti, la correlazione tra il mercato delle criptovalute e il mercato azionario è stata osservata all’inizio del 2022, poco dopo che molti governi hanno allentato le misure di lockdown legate al Covid-19.</p>
<p>Ad esempio, alla fine del 2021 fino all’inizio del 2022 i prezzi delle criptovalute hanno seguito il trend delle azioni. Sono saliti quando il prezzo delle azioni è aumentato e viceversa. Ciò significa che le variabili macroeconomiche influenzano contemporaneamente le criptovalute e le azioni.</p>
<h3 id="h3-Tasso20di20interesse20crescente102067"><a name="Tasso di interesse crescente" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Tasso di interesse crescente</h3><p>L’aumento dei tassi di interesse è stata la principale ragione per cui le criptovalute sono crollate nel 2022. Di fatto, l’intero anno è stato ribassista a causa degli aumenti persistenti dell’inflazione e dei tassi di interesse.</p>
<p>La realtà è che dopo la pandemia, molti paesi, compresi gli Stati Uniti, hanno sperimentato un’inarrestabile inflazione. Al fine di ridurre questa crescente inflazione, alcuni paesi, compresi gli Stati Uniti, hanno aumentato i tassi di interesse. Inoltre, l’aumento dei tassi di interesse ha depresso l’economia globale, riducendo la liquidità nel mercato crittografico.</p>
<p>Sebbene altri fattori abbiano contribuito ai crolli di <a href="/price/terra-luna" target="_blank" class="blog_inner_link">Terra</a> USD e al crollo di FTX, la situazione economica globale depressa ha contribuito indirettamente a ciò. Fondamentalmente, gli aumenti persistenti dei tassi di interesse da parte degli Stati Uniti hanno costretto molti investitori a vendere le loro criptovalute, riducendo la loro capitalizzazione di mercato e rendendole soggette a crolli criptovalutari.</p>
<h3 id="h3-Utilit20limitata54259"><a name="Utilità limitata" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Utilità limitata</h3><p>Un’altra causa del crollo del mercato delle criptovalute è la limitata utilità di alcune criptovalute. Ciò accade perché le monete e i token con utilità minima affrontano sfide di liquidità durante i mercati delle criptovalute ribassisti, come quello che abbiamo vissuto nel 2022. È molto probabile che la bassa liquidità e l’utilità minima abbiano contribuito al crollo di LUNA e FTT.</p>
<p>Il punto qui è che le criptovalute che non hanno molte applicazioni reali convincenti affrontano sfide di liquidità durante i mercati ribassisti. La ragione è che non c’è una domanda sostenuta per tali token o monete.</p>
<p>Inoltre, le criptovalute con una grande capitalizzazione di mercato, come ETH, <a href="/price/bnb-bnb" target="_blank" class="blog_inner_link">BNB</a> e BTC, sono improbabili che crollino durante i mercati ribassisti. Ecco perché queste sono le criptovalute da acquistare ora. Le criptovalute che sopravvivranno all’attuale mercato ribassista saranno i migliori asset di investimento per gli anni a venire, a meno che non si verifichino altre circostanze attenuanti.</p>
<h3 id="h3-Paura20incertezza20e20dubbi630838"><a name="Paura, incertezza e dubbi" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Paura, incertezza e dubbi</h3><p>Paura, incertezza e dubbio (FUD) sono un’altra causa chiave del crollo del mercato crittografico. La causa principale del FUD è la notizia che indica possibilità di una caduta dei prezzi di molte criptovalute.</p>
<p>Una volta che il FUD si impadronisce del mercato, molti investitori potrebbero optare per vendere la loro criptovaluta. Ad esempio, la notizia dell’invasione della Russia dell’Ucraina ha comportato una generale diminuzione dei prezzi di molte criptovalute. Questo perché l’invasione ha comportato un aumento dei prezzi di molte materie prime come determinati alimenti e carburanti. Di conseguenza, c’è stata una riduzione generale del potere d’acquisto di molti potenziali investitori.</p>
<p>Alla fine, alcuni investitori di criptovalute hanno venduto le loro criptovalute al fine di aumentare i loro redditi. Inoltre, notizie negative su una specifica criptovaluta o progetti blockchain possono portare direttamente a crolli delle criptovalute. Ad esempio, le informazioni trapelate su FTX hanno causato il suo crollo.</p>
<h3 id="h3-Cascata20di20vendite20di20criptovalute707301"><a name="Cascata di vendite di criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cascata di vendite di criptovalute</h3><p>L’utilizzo di fondi presi in prestito nel trading è una delle cause principali del crollo delle criptovalute. C’è un debito a margine o trading a margine quando i trader prendono in prestito fondi dai broker ai fini del trading.<br>Gli investitori che prendono in prestito fondi per acquistare criptovalute aumentano le loro possibilità di guadagnare profitti più elevati che altrimenti. Tuttavia, possono anche subire enormi perdite. In generale, i trader che utilizzano una leva elevata sono a grande rischio di liquidazione se il prezzo va nella direzione opposta.</p>
<p>Pertanto, se molti trader utilizzano leve finanziarie elevate e il prezzo dell’attivo diminuisce, tutti si trovano di fronte alla liquidazione. Troppa liquidazione su una piattaforma di trading può innescare un brusco calo del prezzo di una specifica criptovaluta. Poiché molti altri trader vedono il forte calo del prezzo, possono chiudere le loro posizioni. Una tale vendita in massa può riversarsi sul mercato portando a un crollo delle criptovalute.</p>
<h3 id="h3-Manipolazione20di20mercato452235"><a name="Manipolazione di mercato" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Manipolazione di mercato</h3><p>Il calo delle criptovalute potrebbe essere il risultato della manipolazione dei prezzi sul mercato. Alcuni investitori potrebbero scegliere di diffondere FUD sul mercato per forzare il prezzo di una criptovaluta al ribasso.</p>
<p>Grandi gruppi di investitori che detengono grandi quantità di criptovalute (balene) potrebbero cospirare per condurre vendite coordinate di criptovalute. Ciò può portare a brusche e improvvise cadute dei prezzi, causando crolli di mercato.</p>
<h2 id="h2-Eventi20notevoli20e20crolli20delle20criptovalute877082"><a name="Eventi notevoli e crolli delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Eventi notevoli e crolli delle criptovalute</h2><p>Nel 2022 si sono verificati diversi eventi che hanno causato crolli delle criptovalute. In alcuni casi, i crolli delle criptovalute che si sono verificati sono stati il risultato di più di una causa. Tuttavia, in altre circostanze ci sono stati una serie di attività che alla fine hanno portato a crolli delle criptovalute.</p>
<h3 id="h3-Guerra20in20Ucraina243088"><a name="Guerra in Ucraina" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Guerra in Ucraina</h3><p>La guerra in Ucraina è stata uno degli eventi che ha contribuito a alcuni crolli delle criptovalute. In primo luogo, la guerra ha causato carenze di prodotti importanti come grano, fertilizzanti e carburante. In particolare, a seguito dell’invasione della Russia in Ucraina nel febbraio 2022, c’è stata una carenza di gas e carburante in Europa. Ciò ha causato aumenti dei prezzi di queste merci.</p>
<p>Quando i prezzi dei prodotti di cui le persone dipendono maggiormente aumentano, i consumatori spendono più soldi su di essi rispetto a prima. Di conseguenza, il loro reddito disponibile diminuisce e ciò influenza i loro modelli di investimento. Infatti, alcuni smettono di investire in asset rischiosi come le criptovalute. D’altra parte, altri vendono i loro attuali asset di investimento al fine di integrare il loro reddito.</p>
<p>Un altro effetto della guerra è stata la paura di una recessione globale. In alcuni casi, i conflitti geopolitici possono portare a crisi economiche. Pertanto, la paura della recessione dopo l’invasione della Russia dell’Ucraina ha costretto molte persone a vendere le loro criptovalute e azioni. Questo ha contribuito all’emergere dell’inverno delle criptovalute.<br>In pratica, la tensione che è emersa dall’invasione dell’Ucraina ha portato al crollo del mercato globale delle criptovalute di oltre il 10%. Entro 24 ore dall’invasione, il prezzo di ETH è sceso del 12%, quello di <a href="/price/solana-sol" target="_blank" class="blog_inner_link">Solana</a> del 12%, <a href="/price/avalanche-avax" target="_blank" class="blog_inner_link">Avalanche</a> dell’18,2%, <a href="/price/cardano-ada" target="_blank" class="blog_inner_link">Cardano</a> del 18%, <a href="/price/shiba-inu-shib" target="_blank" class="blog_inner_link">Shiba Inu</a> del 18,9%, <a href="/price/dogecoin-doge" target="_blank" class="blog_inner_link">Dogecoin</a> del 16,7% e <a href="/price/polkadot-dot" target="_blank" class="blog_inner_link">Polkadot</a> del 16,2%. In effetti, il prezzo della maggior parte delle principali criptovalute è sceso di margini simili.</p>
<h3 id="h3-Il20crollo20di20FTX381415"><a name="Il crollo di FTX" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il crollo di FTX</h3><p>Oltre all’invasione della Russia dell’Ucraina, l’implosione del Terra USD e di Luna, così come il crollo di FTX, hanno contribuito all’inverno crittografico del 2022. In effetti, questi eventi hanno creato panico e paura nel mercato crittografico. Ciò perché molte persone hanno perso tutti i loro investimenti. Ad esempio, alcuni investitori avevano investito tutti i loro risparmi di una vita in FTX.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673425248111.png" alt=""></p>
<p>FTX è crollato nel 2022 - Theguardian</p>
<p>C’era una serie di eventi che hanno portato al crollo di FTX. Questi includono l’informazione confidenziale trapelata sugli investimenti di FTX in una grande quantità del suo token nativo, FTT, nella sua azienda affiliata Alameda Research. Successivamente, Binance ha venduto la sua grande quantità di FTT, creando il panico sul mercato. Ciò che è seguito è stato un massiccio sell-off del coin FTT e di altre criptovalute sullo scambio FTX, che ha portato al suo crollo.</p>
<p>Inoltre, è stato molto facile per lo scambio di criptovalute collassare poiché circa il 93% dei token FTT erano detenuti solo da 10 portafogli. Pertanto, c’era un’alta possibilità di manipolazione del mercato.</p>
<h2 id="h2-Sono20avvenuti20crolli20di20criptovaluta20prima20del202022304505"><a name="Sono avvenuti crolli di criptovaluta prima del 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Sono avvenuti crolli di criptovaluta prima del 2022?</h2><p>La verità è che prima del 2022 ci sono state altre grandi cadute delle criptovalute, tra cui il Crypto Giovedì Nero. Un altro crollo significativo è avvenuto dopo la chiusura dello scambio Bitfloor nel 2013.</p>
<h3 id="h3-Crypto20Gioved20Nero234508"><a name="Crypto Giovedì Nero" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Crypto Giovedì Nero</h3><p>Il 12 marzo 2020, l’Organizzazione Mondiale della Sanità (OMS) ha dichiarato il Covid-19 come pandemia globale. Di conseguenza, molti paesi come gli Stati Uniti hanno annunciato misure per frenarne la diffusione. Questi sviluppi hanno creato panico tra gli investitori che hanno risposto con massicce vendite di criptovalute e altri titoli.</p>
<p>A seguito della dichiarazione, il prezzo del BTC è sceso di oltre il 40%. Quel crollo non è stato una grande sorpresa poiché l’Asia, con molti investitori di criptovalute, è stata colpita duramente dalla pandemia.</p>
<h3 id="h3-Bitfloor20chiuso506445"><a name="Bitfloor chiuso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Bitfloor chiuso</h3><p>Un’altro grave crollo del BTC si è verificato nel 2013 dopo che la Financial Crimes Enforcement Network (FinCEN) degli Stati Uniti ha chiuso Bitfloor, una prominente borsa di criptovalute. Il prezzo del BTC è sceso di oltre il 70% passando da $260 a $70. A seguito di questo evento, <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> solo recuperato dopo 6 mesi.</p>
<h2 id="h2-I20rischi20dellacquisto20di20criptovalute20durante20un20crollo20delle20criptovalute65285"><a name="I rischi dell’acquisto di criptovalute durante un crollo delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>I rischi dell’acquisto di criptovalute durante un crollo delle criptovalute</h2><p>Molti investitori non vogliono acquistare criptovalute durante un crollo crittografico a causa dei potenziali rischi. Il rischio maggiore è quello della volatilità dei prezzi. Durante un crollo, il prezzo della maggior parte delle criptovalute potrebbe scendere più del previsto, portando a molte perdite.</p>
<p>La paura, l’incertezza e il panico esacerbano gli effetti di un crollo poiché molte persone tendono a vendere le loro posizioni. L’esperienza di ciò che è successo durante i recenti crolli cripto mostra che anche alcuni investitori pazienti tendono a vendere le loro criptovalute durante i periodi di crollo. Ciò può portare all’implosione di alcune criptovalute e al collasso dei progetti cripto.</p>
<p><img src="https://gimg2.gateimg.com/image/article/1673425325222.png" alt=""></p>
<p>TerraUSD è collassato nel maggio 2022 - BBC</p>
<p>Il grafico sopra mostra l’implosione di TerraUSD avvenuta il 9 maggio 2022.</p>
<h2 id="h2-Cosa20fare20durante20un20crollo20delle20criptovalute736878"><a name="Cosa fare durante un crollo delle criptovalute" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Cosa fare durante un crollo delle criptovalute</h2><p>Dopo aver discusso le cause dei crolli delle criptovalute, vediamo cosa possiamo fare durante tali periodi per proteggere i nostri investimenti.</p>
<p>Tieni strette le tue criptovalute: La cosa migliore da fare è tenere strette le tue criptovalute invece di venderle sotto pressione. Quando le vendi sotto pressione, spesso incorri in perdite. Finché non vendi le criptovalute a prezzi inferiori a quelli di acquisto, non subisci perdite.</p>
<h3 id="h3-Gestisci20le20tue20emozioni970539"><a name="Gestisci le tue emozioni" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Gestisci le tue emozioni</h3><p>La cosa chiave da affrontare durante un crollo delle criptovalute è gestire le emozioni. Devi ricordare che i mercati sono ciclici e le correzioni e crolli accadono spesso.</p>
<h3 id="h3-Mantenere20una20prospettiva20a20lungo20termine801143"><a name="Mantenere una prospettiva a lungo termine" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Mantenere una prospettiva a lungo termine</h3><p>È importante che tu consideri gli investimenti in criptovalute come un’operazione a lungo termine. Con questo in mente, ricorda che dopo ogni calo del mercato delle criptovalute si verificherà un rimbalzo. Il punto chiave qui è non concentrarti mai sui grafici delle ultime 24 ore, poiché possono aumentare la paura e il panico. Invece, guarda le fluttuazioni dei prezzi a lungo termine.</p>
<h3 id="h3-Considerare20lacquisto20del20ribasso553075"><a name="Considerare l’acquisto del ribasso" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Considerare l’acquisto del ribasso</h3><p>Le cadute delle criptovalute possono presentare opportunità per gli investitori di acquistare le criptovalute quando i prezzi sono molto bassi. Di conseguenza, otterranno enormi profitti quando il mercato si riprenderà. Pertanto, acquistate durante le cadute delle criptovalute.</p>
<h3 id="h3-Rivaluta20la20tua20strategia20finanziaria824356"><a name="Rivaluta la tua strategia finanziaria" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Rivaluta la tua strategia finanziaria</h3><p>Ci sono cose che devi fare prima che la criptovaluta cada. È importante diversificare il proprio portafoglio. Ciò comporta l’acquisto e la detenzione di diverse criptovalute, il che ridurrà i rischi se alcune di esse subiscono cali di criptovalute.<br>Il costo medio in dollari è un’altra strategia importante per l’acquisizione di criptovalute. Ciò comporta l’utilizzo di una somma fissa di denaro per acquistare criptovalute entro periodi specifici. La maggior parte delle persone acquista le criptovalute settimanalmente o mensilmente quando hanno prezzi diversi.</p>
<h2 id="h2-Conclusion867143"><a name="Conclusion" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Conclusion</h2><p>Il settore delle criptovalute, proprio come il mercato azionario, subisce di tanto in tanto crolli di mercato. Alcune cause dei crolli del mercato delle criptovalute sono eventi globali negativi come guerre e pandemie, instabilità macroeconomica, manipolazione del mercato e FUD. Il Crypto Black Thursday e il <a href="https://www.gate.io/trade/BTC_USDT" target="_blank">Alessio</a> i crolli del mercato a causa della chiusura di Bitfloor sono esempi di crolli di mercato che sono avvenuti prima del 2022.</p>
<h2 id="h2-FAQ597720"><a name="FAQ" class="reference-link"></a><span class="header-link octicon octicon-link"></span>FAQ</h2><h3 id="h3-Le20criptovalute20si20riprenderanno20da20un20crollo20nel202022266138"><a name="Le criptovalute si riprenderanno da un crollo nel 2022?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Le criptovalute si riprenderanno da un crollo nel 2022?</h3><p>È probabile che le criptovalute si riprendano dal crollo di mercato iniziato nel 2022. Tuttavia, la possibilità di ripresa dipende da altri fattori come la stabilizzazione del tasso di inflazione e dei tassi di interesse. Se la Federal Reserve smette di aumentare i tassi di interesse, il crollo delle criptovalute potrebbe terminare. Tuttavia, l’inverno delle criptovalute continuerà nel primo trimestre del 2023, ma potrebbe riprendersi nel secondo trimestre.</p>
<h3 id="h3-Quale20criptovaluta20esploder20nel202023780046"><a name="Quale criptovaluta esploderà nel 2023?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Quale criptovaluta esploderà nel 2023?</h3><p>Diverse criptovalute hanno il potenziale di esplodere nel 2023. In generale, le criptovalute di secondo livello come <a href="/price/optimism-op" target="_blank" class="blog_inner_link">Optimism</a> (OP), Matic, SNX, OMG, LRC, RDN e INJ sono probabili che si rialzino nel 2023. I loro valori potrebbero aumentare rapidamente a causa della domanda dei prodotti che supportano.</p>
<h3 id="h3-Il20202320sar20un20inverno20criptico70062"><a name="Il 2023 sarà un inverno criptico?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il 2023 sarà un inverno criptico?</h3><p>È probabile che l’inverno delle criptovalute arrivi al 2023 a meno che non ci siano cambiamenti chiave nel trend economico globale. Uno dei motivi che perpetuerà l’inverno delle criptovalute nel 2023 è la scarsa fiducia che esiste nel mercato in questo momento, dopo il crollo di FTX, LUNA e TerraUSD. Attualmente, ci sono diversi progetti crypto come BlockFi e Celsius che hanno presentato istanza di fallimento. Questo crea paura nel mercato e riduce la fiducia del mercato.</p>
<h3 id="h3-Il2020232020un20anno20ribassista848627"><a name="Il 2023 è un anno ribassista?" class="reference-link"></a><span class="header-link octicon octicon-link"></span>Il 2023 è un anno ribassista?</h3><p>In base alle attuali prospettive economiche globali, il primo semestre del 2023 è probabile che sia ribassista, mentre il secondo semestre potrebbe diventare rialzista. Attualmente, molti economisti prevedono una probabilità di recessione che potrebbe infliggere ulteriori danni al nascente mercato delle criptovalute. Il secondo semestre del 2023 potrebbe diventare rialzista se la Fed interrompe gli aumenti dei tassi di interesse.</p>
<div class="blog-details-info"><br><div>Autore:<strong> Mashell C.</strong>, Ricercatore di Gate.io<br><div class="info-tips"><em>Questo articolo rappresenta solo le opinioni del ricercatore e non costituisce alcun suggerimento di investimento.<br></em><div><em></em>Gate.io si riserva tutti i diritti su questo articolo. La ripubblicazione dell'articolo sarà consentita a condizione che sia citato Gate.io. In tutti i casi, saranno intraprese azioni legali per violazione dei diritti d'autore.<br></div><p></p><br></div></div></div>