53 ‘EMOTION OF THE WEEK

【BEST SONGS 2020】

YouTube Playlist

Spotify Playlist

best songs 2020

As you know, Trembol presents 1 new and exciting song every week. Music of all genres, languages, and countries. As the year is over we have compiled the 53 best songs of 2020.

Let’s put good music and a big smile on this 2020!

You might also like:

📋 Tracklist 53 Best Songs 2020 〖 Artist | Song | Description in 4 words | Country 〗
  1. Alex Palomo 1 Día (1 Day) | Young Promising Talent | Spain
  2. Robin Schulz ft. Alida In Your Eyes | Dance Hit | Germany
  3. Destiny All My Love | Eurovision song | Malta
  4. Of Monsters and Men Visitor | Indie Rock | Island
  5. Marta Soto Podrás Contar Conmigo (You can count on me) | Young Promising Talent | Spain
  6. Movin Sunrise | Machine Music | United Kingdom
  7. Diodato Fai Rumore (Make Noise) | San Remo | Italy
  8. Holly Humberstone Falling Asleep at the Wheel | Young Singer-songwritter | United Kingdom
  9. Derbi Motoreta’s Burrito Cachimba El Valle (The Valley) | Alternative Psychedlic | Spain
  10. Der Astronaut Back To The Moon | Our favourite | Germany
  11. Miley Cyrus Midnight Sky | Long live the 80s | United States
  12. Beyond the Black Human | Ghotic Rock | Germany
  13. Austra Anywayz | New Wave Canada
  14. Topic & A7S Breaking Me | Stylish Dance | Germany
  15. Cami & WOS Funeral | Young Promising Talent | Chile
  16. Nea (Felix Jaehn Remix) Some Say | ‘Eiffel 65 – Blue’ Sample | Sweden
  17. Paloma Faith Better Than This | Good Pop | United Kingdom
  18. Jason Derulo Take You Dancing | TikTok Dance | United Kingdom
  19. Patrick Fiori & Florent Pagny J’y vais (I’m coming) | 2 Great French artists | France
  20. Efecto Pasillo ft. Sinsinati Similares (Similar) | Pop bands fusion | Spain
  21. Michael Stripe & Big Red Machine No Time For Love Like Now | Very true | United States
  22. Kylie Minogue Magic | Tireless Kylie | Australia
  23. Murilo Huff & Henrique e Juliano Desejando Eu (Me wishing) | Live from Brazil | Brazil
  24. Biffy Clyro Space | Must-listen song | United Kingdom
  25. дора Втюрилась (She got into trouble) | Russian Young Talent | Russia
  26. Monica Naranjo Autómata (Automaton) | Electro-pop power | Spain
  27. Machine Gun Kelly Bloody Valentine | Cool Hip-hop | United States
  28. Tommee Profitt Noel, he is born | Epic Carol | United States
  29. Ray LaMontagne We’ll Make It Through | American music with soul | United States
  30. Katy Perry Not The End Of  The World | Cool Pop | United States
  31. Bad Bunny Maldita Pobreza (Damn Poverty) | Finally good trap | Puerto Rico
  32. Palaye Royale Lonely | Very Dark | United States
  33. Aitana ft. Marmi Tu Foto del DNI (Your ID card photo) | Long live Autotune | Spain
  34. Kaleo I Want More | Happy tears | Island
  35. Jubël Someone | Good Vibe | Sweden
  36. Alesso feat. Liam Payne Midnight | Gorgeous Dance Song | Sweden and United Kingdom
  37. Alejandro Fernández Te Olvidé (I Forgot you) | Mexican Ranchera | Mexico
  38. The 1975 If You’re Too Shy (Let Me Know) | Renovated Brit Pop | United Kingdom
  39. Lindsey Stirling ft. Kiesza What You’re Made Of | Fiddle to the heart | United States and Canada
  40. Justin Bieber & Benny Blanco Lonely | Honest truth | United States and Canada
  41. Jessie Ware Save a Kiss | Great and Elegant | United Kingdom
  42. Delta Goodrem Solid Gold | Empowerment | Australia
  43. C. Tangana Demasiadas Mujeres (Too Many Women) | It’s never enough | Spain
  44. Tiwa Savage & Sam Smith Temptation | Classy relax | Nigeria and United Kingdom
  45. Kodaline This Must Be Christmas | Other kind of Carol | United Kingdom
  46. Chica Sobresalto Fusión del Núcleo (Core Fusion) | Music Future | Spain
  47. Bruce Springsteen Ghosts | Band Rock | United States
  48. The Weeknd Blinding Lights | Worldwide No.1 | Canada
  49. Lady Gaga & Elton John Sine from Above | Let’s Dance | United States and United Kingdom
  50. Mustafa Ceceli & İrem Derici feat. Sinan Akçıl Çok Sevmek Yasaklanmalı (Loving Too Much Should Be Forbidden) | I love this music | Turkey
  51. Dua Lipa Physical | Another Worldwide No.1 | United Kingdom
  52. Welshy Arms Learn to Let Go | Next favourite song | United States
  53. Mickey Guyton Black Like Me | From the depths | United States

The Best 2020 Music 🎙️ 20 Outstanding Songs

TIWA SAVAGE & SAM SMITH 🎙 Temptation

Nigeria and UK | 2020
Facebook, Twitter, Instagram
  • Temptation” is subtle and soft music with Afrobeats that give the song a magic touch. Perfect to chill out along with the rest of songs from our Relaxing Music Playlist
  • Tiwa Savage is a Nigerian artist who began her career doing backup vocals for George Michael and Mary J. Blige. She participated without much success in the The X Factor in UK, no matter that she ended up being the first Afro-American woman wining MTV’s “Best African Act” award.
  • Sam Smith had teamed up with another famous Nigerian singer, Burna Boy, in his single ‘My Oasis’, only one month before.
  • Tiwa Savage sings in English and Yoruba (a dialect from Western Africa).

DUA LIPA 🎙 Physical

UK | 2020
dualipa.com

RAY LaMONTAGNE 🎙 We’ll Make It Through

USA | 2020
raylamontagne.com
  • An American singer-songwriter who makes your hair stand on end. Ray LaMontagne released in 2020 his latest album “Monovision(which we highly recommend), with this intimate song that is magical.
  • After the hard year we’ve lived through, you are bound to find comfort in the brilliant humanity of Ray’s music.
  • The song says:

I know you’re scared, can’t see the light
Got to believe it’s gonna be alright
Lean on me and I’ll lean on you
And together, we’ll get through
We always do

Delta Goodrem Facebook Image

🎙Delta Goodrem Solid Gold

Australia | 2020
deltagoodrem.com
  • The great Australian singer who became famous worldwide in 2003 with her “Innocent Eyes”, has continued to reap successes since then and in 2020 she released Solid Gold”, a song full of energy and good vibes.
  • Delta described it:

It’s an empowering song about reminding someone of your worth and strength; a song you sing along to with your mates and jam out to in the car with all the windows down

  • The singer later revealed the song was inspired by her recovery from nerve damage to her tongue, which caused loss of regular speech function.
    <script data-rocketlazyloadscript='data:text/javascript;base64," title="<script>"></p> 
<p><ins class="adsbygoogle" style="display: block; text-align: center;" data-ad-layout="in-article" data-ad-format="fluid" data-ad-client="ca-pub-2901961548245067" data-ad-slot="9652240186" data-mce-style="display: block; text-align: center;"></ins><br /></p> 
<p><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%3E%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%20%20%20%20%20(adsbygoogle%20%3D%20window.adsbygoogle%20%7C%7C%20%5B%5D).push(%7B%7D)%3B%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row -->
				
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_9 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/12/Patrick-Fiori-Florent-Pagny-Jy-vais.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_19    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_16  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>PATRICK FIOIR &amp; FLORENT PAGNY <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript><em> J'y Vais (I'm Going)</em></h3><h6>FRANCE | 2020</h6><h6><a href="https://patrickfiori.sonymusic.fr/" target="_blank" rel="noopener noreferrer" data-mce-href="https://patrickfiori.sonymusic.fr/">patrickfiore.fr</a></h6><ul><li><strong>2 superb French singers, <em>Patrick Fiori </em></strong>and<strong><em> Florent Pagny</em>&nbsp;</strong>join forces in this <span style="color: #e66a05;" data-mce-style="color: #e66a05;"><strong>powerful and moving song</strong></span><strong>.</strong></li><li>Patrick Fiori&nbsp;started being known thanks to his role in the musical <em>Notre Dame de Paris</em>, and in 2020 he was releasing his 11th album, which includes our&nbsp;“<em>J’y Vais</em>”.</li><li>10 years is the time <em><strong>Patrick Fiori</strong></em> waited to offer <strong><em>Florent Pagny</em></strong>&nbsp;the right song that would unite their voices.</li><li>The tune takes us on a search for the child within us, who always guides our steps.</li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_20   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_12">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_16 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_17  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_40790"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/J_w0RRqDemo?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Patrick Fiori, Florent Pagny - J&#039;y vais (Clip officiel)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/J_w0RRqDemo"><meta itemprop="name" content="Patrick Fiori, Florent Pagny - J&#039;y vais (Clip officiel)"><meta itemprop="description" content="Le nouvel album de Patrick Fiori &quot;Un air de famille&quot; maintenant disponible : https://patrickfiori.lnk.to/AlbumUnAirDeFamille Chanson écrite par Bruno Guglielmi &amp; composée par Patrick Fiori Clip co-écrit par Carole Mathieu-Castelli &amp; Patrick Fiori et réalisé par Carole Mathieu-Castelli &amp; Thierry Humbert pour Makam Films ----- Retrouvez Patrick Fiori sur : Site officiel : http://patrickfiori.sonymusic.fr Facebook : https://www.facebook.com/patrickfioriofficiel Twitter : https://twitter.com/patrickfiorioff Abonnez-vous à la chaîne VEVO de Patrick Fiori : https://www.youtube.com/user/patrickfioriVEVO?sub_confirmation=1"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/J_w0RRqDemo/0.jpg"><meta itemprop="duration" content="PT3M43S"><meta itemprop="uploadDate" content="2020-10-30T07:00:02Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_13">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_17">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_11  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2KLU4vt" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_18 et-last-child">
				
				
				<div class="et_pb_module et_pb_code et_pb_code_12  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/3mJIL4B" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_14">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_19 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_18  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image&nbsp;<a target="_blank" rel="noopener noreferrer">| Patrick Fiore Image from his Website</a></p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_10 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/12/Murilo-Huff-Henrique-e-Juliano-Desejando-Eu.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_21   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_15">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_20 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_19  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_39392"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/oP41rSTayac?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Murilo Huff &amp; Henrique e Juliano - Desejando Eu (Vídeo Oficial)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/oP41rSTayac"><meta itemprop="name" content="Murilo Huff &amp; Henrique e Juliano - Desejando Eu (Vídeo Oficial)"><meta itemprop="description" content="CONTATO PARA SHOWS: (62) 98233-0008 / 3996-2333 vendas&#064;artinvox.com.br Ouça nas plataformas digitais: https://ffm.to/desejandoeu DESEJANDO EU Já que voltou com o seu ex Poderia, ao menos, Esconder suas brigas Dos nossos amigos Pra não chegar nos meus ouvidos Mas já que eu fiquei sabendo Tomara que você sofra Encontre ele com outra E que você se arrependa amargamente E que sinta muita, muita Muita saudade da gente Não tô te desejando mal Você não percebeu Que eu só tô te desejando eu Não tô te desejando mal Você não percebeu Que eu só tô te desejando eu Só tô te desejando eu Só tô te desejando eu Composição: Bruno Sucesso / Ricardo Vismarck / Ronael / Marcelo Henrique / Elan Rubio Ficha Técnica: Direção: Calango Filmes Produção Musical: Matheus Phelipe (Studio Roça) Direção Executiva: Artinvox Produções Marketing: Luana Müller | Lorena Carmo Direção de Arte: Brenda Machado #murilohuff #henriqueejuliano #desejandoeu"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/oP41rSTayac/0.jpg"><meta itemprop="duration" content="PT2M47S"><meta itemprop="uploadDate" content="2020-03-05T14:03:04Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_16">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_21">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_13  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/3oNGneh" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_22 et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_14  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/2INqg16" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_17">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_23 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_20  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Murilo Huff Facebook Image</p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_22    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_21  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript> Murilo Huff&nbsp;&amp; Henrique e Juliano <em>Desejando Eu (Wishing You)</em></h3><h6>Brazil | 2020</h6><h6><a href="https://oficialmurilohuff.com.br/" target="_blank" rel="noopener noreferrer" data-mce-href="https://oficialmurilohuff.com.br/">oficialmurilohuff.com.br</a></h6><ul><li>Murilo Huff is a Brazilian composer who, at 25, has already reached tremendous success with more than 197 million views on YouTube and 148 million streams on Spotify.</li><li>He has already released the second part of his album<strong>&nbsp;</strong>“<em>Pra Ouvir Tomando Uma (To Hear Taking One)</em>”, after which he has released this wonderful single in 2020 sung with the <strong>Brazilian stars <em>Henrique e Juliano,</em></strong><em>&nbsp;<strong>“Desejando Eu”.</strong></em></li><li><strong>Live music always sounds better</strong> and in Brazil they know it very well, almost all albums are live, like <em>Murilo Huff</em>’s song.<br data-mce-bogus="1"></li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_11 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/12/Diodato-Fai-Rumore.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_23    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_22  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>DIODATO <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript><em> Fai Rumore (Make Noise)</em></h3><h6>ITALY | 2020</h6><h6><a href="http://www.diodatomusic.it/" target="_blank" rel="noopener noreferrer" data-mce-href="http://www.diodatomusic.it/">www.diodatomusic.it</a></h6><ul><li><strong><em>Diodato</em>&nbsp;won the prestigious Italian festival&nbsp;<em>San Remo in 2020</em></strong>&nbsp;and was going to represent Italy in&nbsp;<em>Eurovision 2020</em>, canceled due to COVID-19<em>. </em>I think he would’ve won as well with this&nbsp;<span style="color: #e66a05;" data-mce-style="color: #e66a05;"><strong>passionate song.</strong></span></li><li><em><strong>“Fai Rumore (Make Noise)”</strong></em>, is a song written for his ex-girlfriend and the silence that their breakup left in his life. Who hasn’t felt that sensation!</li><li>The tune belongs to the fourth album of this amazing singer-songwriter&nbsp;<em>“<i>Che vita meravigliosa</i>”. </em><strong>Pure feeling</strong>.</li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_24   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_18">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_24 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_23  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_35240"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/tPv9ZPXmFWU?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Diodato - Fai Rumore (Video Ufficiale) [Sanremo 2020]"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/tPv9ZPXmFWU"><meta itemprop="name" content="Diodato - Fai Rumore (Video Ufficiale) [Sanremo 2020]"><meta itemprop="description" content="Brano vincitore del Festival di Sanremo 2020. #Sanremo2020 #Sanremo70 Ascolta #FaiRumore: https://orcd.co/fairumore Ascolta l&#039;album Che Vita Meravigliosa: https://orcd.co/chevitameravigliosa-album Segui #Diodato Facebook: https://www.facebook.com/DiodatoOfficial Instagram: https://www.instagram.com/diodatomusic Twitter: https://twitter.com/diodatomusic Spotify: https://orcd.co/diodato YouTube: https://orcd.co/diodato director: Giorgio Testi executive producer: Martina Zambeletti produced by Pulse Films powered by Indiana Production dancer: Veronica Josephine Sormani production manager: Pablo Casula production assistant: Federico Notaro director of photography: Luca Ciuti editor: Marcello Saurino colorist: Giorgia Meacci 1st ac: Silvio Bersani 2nd ac: Sara Angelucci dit: Giovanni Fiormarino trinity operator: Emilio Giliberti trinity assistant: Julien Dehers gaffer: Andrea Rostellato electrician: Antonio Cirelli key Grip: Luca Morini grip: Mustapha Mezzi stylist: Carlotta Borgogna make up artist: Selene Colonna set designer: Francesca Manuele transports: Brother Service contact: Mircea Ciolan studio: MovieChrome catering: Cinecucine #CheVitaMeravigliosa"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/tPv9ZPXmFWU/0.jpg"><meta itemprop="duration" content="PT3M46S"><meta itemprop="uploadDate" content="2020-02-05T00:01:00Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_19">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_25">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_15  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/36JZG1X" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_26 et-last-child">
				
				
				<div class="et_pb_module et_pb_code et_pb_code_16  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/3mQ679c" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_20">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_27 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_24  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image&nbsp;<a target="_blank" rel="noopener noreferrer">| Diodato Image from Facebook</a></p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_12 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/11/Paloma-Faith-Better-Than-This-1.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_25   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_21">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_28 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_25  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_73762"  width="1080" height="810"  data-origwidth="1080" data-origheight="810"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/D_jSRdQChsI?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Paloma Faith - Better Than This (Official Video)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/D_jSRdQChsI"><meta itemprop="name" content="Paloma Faith - Better Than This (Official Video)"><meta itemprop="description" content="Paloma Faith - Better Than This (Official Video) Listen to &#039;Better Than This&#039; here: https://smarturl.it/BetterThanThisPF Apple Music: https://smarturl.it/BetterThanThisPF/applemusic Spotify: https://smarturl.it/BetterThanThisPF/spotify Itunes: https://smarturl.it/BetterThanThisPF/itunes YouTube Music: https://smarturl.it/BetterThanThisPF/youtubemusic Amazon Music: https://smarturl.it/BetterThanThisPF/amazonmusic Deezer: https://smarturl.it/BetterThanThisPF/deezer WATCH LOYAL MUSIC VIDEO ► https://smarturl.it/Paloma_LYT WATCH ONLY LOVE CAN HURT LIKE THIS MUSIC VIDEO ► https://smarturl.it/Paloma_OLCHLTYT WATCH PICKING UP THE PIECES MUSIC VIDEO ► https://smarturl.it/Paloma_PUTPYT WATCH CAN’T RELY ON YOU MUSIC VIDEO ► https://smarturl.it/Paloma_CROYYT WATCH NEVER TEAR US APART MUSIC VIDEO ► https://smarturl.it/Paloma_NTUAYT WATCH JUST BE MUSIC VIDEO ► https://smarturl.it/Paloma_JBYT Follow Paloma Faith: Subscribe - http://smarturl.it/PF_YTsub Website - palomafaith.com Instagram - https://www.instagram.com/palomafaith/ Twitter - https://twitter.com/Palomafaith Facebook - https://www.facebook.com/palomafaith/ Lyrics: When the lights in my street go out and All the people lie sleeping under clouds and they’re dreaming of better than this Then my brother calls me and he’s sayin Oh I can hear the angels praying that we Can do better than this Coz I saw a mountain I thought “it’s too high” I heard the birds whisper “Ya can’t fly” I saw you and I thought I can do better than this better than this I heard a language I thought I can’t speak I saw an ocean I thought was too deep I see you and I know we can do better than this better than this And I know you’ll take me Anywhere I wanna go and I Know you’ll make me learn everything that I wanna know The truth of it is, it doesn’t get better than this When the riddles and the puzzles find me I wanna let the darkness hide me but I know There is better than this And I’m shouting coz I see my failings, My fears my faults I’m raging, coz I know That I’m better than this Coz I saw a mountain I thought “it’s too high” I heard the birds whisper “Ya can’t fly” I saw you and I thought I can do better than this better than this I heard a language I thought I can’t speak I saw an ocean I thought was too deep I see you and I know we can do better than this better than this And I know you’ll take me Anywhere I wanna go and I Know you’ll make me learn everything that I wanna know The truth of it is, it doesn’t get better than this Ohhh Ohhh Only when we discover that’s how we find each other that’s when we, both get better than this... #PalomaFaith #PalomaFaithBetterThanThis #BetterThanThis PRODUCTION - RIFF RAFF FILMS DIRECTOR: DAVID WILSON OWNER: MATTHEW FONE EXEC PRODUCER: NATALIE ARNETT PRODUCER: KATE BRADY COMMISSIONER: MICHAEL LEWIN CREATIVE DIRECTOR: THEO ADAMS DOP: DAVID FOULKES PRODUCTION MANAGER: NATALIE STEINER PRODUCTION ASSISTANTS: RACHEL BASHFORD, MELISSA ROBERTS RUNNERS: DAVID BURRIDGE, ALI COPELAND, ALICE CARLET 1ST AD: BEN GLICKMAN 2ND AD: GABRIEL O&#039;DONOHOE FOCUS PULLER: KATE ECCARIUS 2ND AC: JAMES MALAMATINIS DIT: LIAM LINTONBON AUDIO PLAYBACK: CHARLOTTE HOMESHAW GAFFER: ALEX GIBBON ELECTRICIANS: CRAIG PALMER, ORLANDO DESILVA, DAK KANNAN RIGGERS: TIMOTHY PETHERICK, GEOFFREY PETHERICK KEY GRIP: NEIL BEARDSLEY PRODUCTION DESIGNER: ELIZABETH EL-KADHI BROWN MOVEMENT COACH: THEO TJ LOWE ARTIST STYLIST: PHOEBE ARNOLD ARTIST MAKE UP: LAN NGUYEN GEEALIS ARTIST HAIR: DECLAN SHEILS ARTIST NAILS: IMANI RUNNERS: ALICE CARTLET, ALI COPLAND VIDEO ENGINEERS: JUSTIN BEARSDELL, JESS HARVEY, WILL CUNNINGHAM, ZAC MUGGLETON POST PRODUCTION – EDITOR: BRENDAN JENKINS – TENTREE EDITING STOCK FOOTAGE EDITOR: NIALL TRASK STOCK FOOTAGE EDITOR: MORGAN DWYER STOCK FOOTAGE EDITOR: ANDY LOVELEE TYPOGRAPHY GRAPHICS: PETER COLLINS POST HOUSE: BLACK KITE COLOURIST: RICH FEARON POST PRODUCER: TAMARA MENNELL VFX LEAD: HUGO SAUNDERS SOUND HOUSE: GRAND CENTRAL ADDITIONAL POST: 24/7 PRODUCTIONS POST PRODUCER: BEKI MARI FLAME ARTIST: YANN MASSON LABEL - SONY UK MARKETING: SIMON FORBES ARTIST/MNG: LATERAL MANAGEMENT ARTIST: PALOMA FAITH MANAGER: INNIS FERGUSON ASSISTANT: RADHIKA WILSON PA: TASHA BRADE BTS PHOTO: ELLIOT MORGAN BTS VIDEO: SAM SUTHERLAND http://vevo.ly/md0e3B"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/D_jSRdQChsI/0.jpg"><meta itemprop="duration" content="PT3M32S"><meta itemprop="uploadDate" content="2020-09-11T16:00:05Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_22">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_29">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_17  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2JcMdXI" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_30 et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_18  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/39l9hOy" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_23">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_31 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_26  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Paloma Faith Facebook Image</p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_26    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_27  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>Paloma Faith <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>&nbsp;<em>Better Than This</em></h3><h6>UK | 2020</h6><h6><a href="https://www.palomafaith.com" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.palomafaith.com">palomafaith.com</a></h6><ul><li>Paloma is worth knowing. <strong>Eclectic and with a kind of retro style</strong>, she is starting to find hard to keep track of all her number 1 in the UK.</li><li><strong>“<em>Better Than This</em>” </strong>is the first single of her fifth and new album&nbsp;<strong>“<em>Infinite Things</em>”</strong>, which she describes as:<br><blockquote><p><em>It’s love songs for people who are there to stay. That enduring love. Warts and all. I don’t think I’ve ever heard a love song like that, actually.</em></p></blockquote></li><li>There are songs that really touch inside. Listen to this tune carefully and I’m sure you will feel like that. It’s gorgeous! 🖤</li><li>By the way, if want to listen to more Paloma Faith, visit our <a href="/?p=15702" target="_blank" rel="noopener noreferrer" data-mce-href="https://trembol.com/en/best-workout-songs-of-all-time-running-songs-gym-music/"><em>Workout Playlist</em></a></li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_13 et_section_regular" >
				
				
				
				
					<div class="et_pb_row et_pb_row_9">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_27  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_19  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%20async%20src%3D%22https%3A%2F%2Fpagead2.googlesyndication.com%2Fpagead%2Fjs%2Fadsbygoogle.js%22%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></p> 
<p><ins class="adsbygoogle" style="display: block; text-align: center;" data-ad-layout="in-article" data-ad-format="fluid" data-ad-client="ca-pub-2901961548245067" data-ad-slot="9652240186" data-mce-style="display: block; text-align: center;"></ins><br /></p> 
<p><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%3E%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%20%20%20%20%20(adsbygoogle%20%3D%20window.adsbygoogle%20%7C%7C%20%5B%5D).push(%7B%7D)%3B%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row -->
				
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_14 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/11/Jason-Derulo-Take-You-Dancing-1.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_28    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_28  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>JASON DEURLO <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript><em> Take You Dancing</em></h3><h6>USA | 2020</h6><h6><a href="https://www.jasonderulo.com/" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.jasonderulo.com/">www.jasonderulo.com</a></h6><ul><li>‘<em>Da, da, da, da, da, da’</em>, <strong>I can’t take this melody out of my head</strong>, so I decided to infect you 😷, if you weren’t already!</li><li>Mr. Derulo, has managed to reinvent his career, based on very danceable songs, usually spicy and with many falsettos; thanks to&nbsp;<em>TikTok</em>.</li><li>After&nbsp;<em><strong>“Savage Love” </strong></em>success, he brings us a tune with&nbsp;<a href="https://www.youtube.com/watch?v=vC8qJfVYxZY" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.youtube.com/watch?v=vC8qJfVYxZY">video-choreography</a>&nbsp;included, to <strong>keep&nbsp;ruling on social media</strong>.</li><li>The song serves its purpose more than enough, as Jason Derulo himself says:</li></ul><blockquote><p>In these times, we all need a song that’s going to uplift us. Hopefully <em>Take You Dancing</em> can be a light in these trying days</p></blockquote></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_29   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_24">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_32 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_29  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_15339"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/s0-f5RncxcA?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Jason Derulo - Take You Dancing [Official Music Video]"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/s0-f5RncxcA"><meta itemprop="name" content="Jason Derulo - Take You Dancing [Official Music Video]"><meta itemprop="description" content="Jason Derulo - Take You Dancing [Official Music Video] Stream/Download: https://jasonderulo.lnk.to/TakeYouDancing CONNECT WITH JASON DERULO:‬ TikTok - https://www.tiktok.com/&#064;jasonderulo ‪Instagram - http://www.instagram.com/jasonderulo/ ‪Facebook - http://facebook.com/jasonderulo ‪Twitter - http://twitter.com/jasonderulo ‪Official Website - http://www.jasonderulo.com/ #JasonDerulo #TakeYouDancing #OfficialMusicVideo"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/s0-f5RncxcA/0.jpg"><meta itemprop="duration" content="PT3M24S"><meta itemprop="uploadDate" content="2020-08-27T18:59:06Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_25">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_33">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_20  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2UPrCdZ" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_34 et-last-child">
				
				
				<div class="et_pb_module et_pb_code et_pb_code_21  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/3lTuUsM" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_26">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_35 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_30  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image&nbsp;<a target="_blank" rel="noopener noreferrer">| Jason Derulo Image from Facebook</a></p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_15 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/11/дора-—-Втюрилась.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_30   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_27">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_36 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_31  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_40088"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/ewCPQeAtICk?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="дора — Втюрилась"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/ewCPQeAtICk"><meta itemprop="name" content="дора — Втюрилась"><meta itemprop="description" content="Смотреть клип: https://youtu.be/FAAM7wdtXmg Трек доступен на всех цифровых площадках: https://bnd.lc/i6U6d Слушать в BOOM: vk.cc/ayx6OK Booking: booking&#064;realdora.com — Ника, +7 (958) 709-16-67 PR&amp;Cooperation: pr&#064;realdora.com — Дина дора в социальных сетях: https://vk.com/babydori https://www.instagram.com/mentaldora/ #дора #втюрилась"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/ewCPQeAtICk/0.jpg"><meta itemprop="duration" content="PT2M4S"><meta itemprop="uploadDate" content="2020-08-26T21:00:07Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_28">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_37">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_22  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/36BJajo" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_38 et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_23  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/32J94Re" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_29">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_39 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_32  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p><a href="https://vk.com/babydori?z=photo-91010741_457243427%2Falbum-91010741_00%2Frev" target="_blank" rel="noopener noreferrer" data-mce-href="https://vk.com/babydori?z=photo-91010741_457243427%2Falbum-91010741_00%2Frev">дора Image from VK</a></p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_31    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_33  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>дора (Dora) <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript><em> Втюрилась</em></h3><h6>Russia | 2020</h6><h6><a href="https://www.youtube.com/channel/UCae-zZkho0dkoQ5Z_NJhpeg" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.youtube.com/channel/UCae-zZkho0dkoQ5Z_NJhpeg">YouTube</a>, <a href="https://www.instagram.com/mentaldora/" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.instagram.com/mentaldora/">Instagram</a>, <a href="https://vk.com/babydori" target="_blank" rel="noopener noreferrer" data-mce-href="https://vk.com/babydori">VK</a></h6><ul><li>дора (Dora), is the artistic name of Daria Shikhanova, a young (20 years old in 2020) singer and composer born in Saratov (Russia).</li><li>She calls her music&nbsp;<strong>“Cute Rock”</strong>, and truth is that this song&nbsp;<strong>“<em>Втюрилась</em>”</strong>&nbsp;fits that definition perfectly 😺</li><li>Did you know that she chose her name because as a child she loved ‘<em>Dora the Explorer</em>‘ cartoon?</li><li>If you want more of her music, we recommend “<a href="https://www.youtube.com/watch?v=e8aGBWPA6NA" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.youtube.com/watch?v=e8aGBWPA6NA"><em>Пошлю Его На…. (Send it…)</em></a>”.<strong>&nbsp;We</strong>&nbsp;<strong>predict&nbsp;her a great career.</strong></li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_16 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/11/Cami-Funeral.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_32    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_34  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>CAMI <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript><em>&nbsp;Funeral</em></h3><h6>Chile | 2020</h6><h6><a href="https://twitter.com/soycamioficial" target="_blank" rel="noopener noreferrer" data-mce-href="https://twitter.com/soycamioficial">Twitter</a>, <a href="https://www.instagram.com/cami/" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.instagram.com/cami/">Instagram</a>, <a href="https://twitter.com/soycamioficial" target="_blank" rel="noopener noreferrer" data-mce-href="https://twitter.com/soycamioficial">Facebook</a></h6><ul><li>2020 is the year of emergence of this young Chilean artist, known thanks to the program<em> The Voice</em>, a good debut album,&nbsp;“<em>Rosa (Rose)</em>”, and several successful collaborations: <em><a href="https://www.youtube.com/watch?v=LB8-bIhl_d8" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.youtube.com/watch?v=LB8-bIhl_d8">Un Millon Como Tu</a>&nbsp;(with Lasso), <a href="https://www.youtube.com/watch?v=qOwHXCpAIME" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.youtube.com/watch?v=qOwHXCpAIME">Codependientes</a> (with Jose Madero).</em></li><li><strong>Cami brings a lot of character to her music</strong>, and that is reflected in her new album,&nbsp;<em><strong>“Monstruo (Monster)”</strong></em>. A folk-rock fusion in which the song that we have selected,&nbsp;<em><strong>“Funeral”,</strong></em>&nbsp;with the Argentine rapper&nbsp;<em>WOS</em>, stands out.</li><li>Cumbia, salsa, and pop in a combination that is <strong>one of the best songs of 2020</strong> 💃<br data-mce-bogus="1"></li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_33   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_30">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_40 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_35  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_82413"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/psJ1TWSUsOk?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Cami - Funeral ft. WOS"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/psJ1TWSUsOk"><meta itemprop="name" content="Cami - Funeral ft. WOS"><meta itemprop="description" content="Sigue a CAMI en: Facebook: https://www.facebook.com/camigallardo... Twitter: https://twitter.com/soycamioficial Instagram: https://www.instagram.com/cami/ Music video by Cami performing Funeral. © 2020 Universal Music Chile http://vevo.ly/gP07oy"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/psJ1TWSUsOk/0.jpg"><meta itemprop="duration" content="PT3M45S"><meta itemprop="uploadDate" content="2020-02-19T03:00:11Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_31">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_41">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_24  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2IIyCXd" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_42 et-last-child">
				
				
				<div class="et_pb_module et_pb_code et_pb_code_25  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/38Og0QH" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_32">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_43 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_36  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image&nbsp;| Cami Image from Facebook</p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_17 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/11/Kylie-Minogue-Magic_1.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_34   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_33">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_44 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_37  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_78075"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/vzZn31gd_Jc?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Kylie Minogue - Magic (Official Video)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/vzZn31gd_Jc"><meta itemprop="name" content="Kylie Minogue - Magic (Official Video)"><meta itemprop="description" content="The Official Video for Magic by Kylie Minogue from the new album DISCO out now. Buy/Listen: https://Kylie.lnk.to/Discoyv Listen: https://Kylie.lnk.to/MagicID LYRICS: I feel like anything could happen The stars look different tonight They glowing all around me It’s flowing through my body I can feel it I can feel it You got me started Ain’t nothing on earth can stop it It’s crazy I’m falling I don’t know what else to call it Oh do you believe in magic Do you do you do you Do you believe in magic Oohhh Dancing together Ain’t nothing that could be better Tomorrow don’t matter We’ll make the night last forever So do you believe in magic Do you do you do you Do you believe in magic Oohhh You make me wanna do these wild things Your touch is supernatural Oh I can’t fight this feeling I’m floating through the ceiling Can you feel it I can feel it Ohh Chorus Magic magic magic magic Do you believe in Do you believe in Magic magic magic magic Do you believe in magic Chorus Follow Kylie: https://www.kylie.com https://www.facebook.com/kylieminogue https://www.instagram.com/kylieminogue https://twitter.com/kylieminogue Subscribe: https://www.youtube.com/user/kylieminogue/?sub_confirmation=1 Video Director: Sophie Muller Video Producer: Chris Murdoch/Juliette Larthe Production Company: Prettybird #Kylie #Magic #DISCO"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/vzZn31gd_Jc/0.jpg"><meta itemprop="duration" content="PT3M41S"><meta itemprop="uploadDate" content="2020-09-24T18:00:12Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_34">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_45">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_26  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2U4oZob" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_46 et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_27  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/358y5GP" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_35">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_47 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_38  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Kylie Minogue DISCO Image from Facebook</p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_35    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_39  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>KYLIE MINOGUE <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript><em> Magic</em></h3><h6>Australia | 2020</h6><h6><a href="https://www.kylie.com/" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.kylie.com/">kylie.com</a></h6><ul><li>The <strong>Australian who has sold more albums in history</strong>&nbsp;is back with her 15th studio record, can you believe it!</li><li>At her amazing 52, she releases&nbsp;<strong>“DISCO”</strong>.<strong>&nbsp;A return to the </strong><strong>80s</strong>, as many artists are doing (<em><strong><a href="/?p=5985" target="_blank" rel="noopener noreferrer" data-mce-href="https://trembol.com/en/playlist-hits-all-time-number-ones/">Dua Lipa</a>, <a href="/?p=11235" target="_blank" rel="noopener noreferrer" data-mce-href="https://trembol.com/en/abc-band-martin-fry-viva-love/">ABC</a>, <a href="https://trembol.com/en/starboy-the-weeknd-albums/the-weeknd-blinding-lights" target="_blank" rel="noopener noreferrer" data-mce-href="https://trembol.com/en/starboy-the-weeknd-albums/the-weeknd-blinding-lights">The Weeknd</a></strong></em>)</li><li>Did you know that because of the COVID-19, he had to record almost the entire album at home and had to learn how to use the recording software? <strong>It’s never too late to start anything</strong>, and the proof is this wonderful single,&nbsp;<strong>“Magic”</strong> 🔮<br data-mce-bogus="1"></li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_18 et_section_regular" >
				
				
				
				
					<div class="et_pb_row et_pb_row_10">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_36  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_28  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%20async%20src%3D%22https%3A%2F%2Fpagead2.googlesyndication.com%2Fpagead%2Fjs%2Fadsbygoogle.js%22%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></p> 
<p><ins class="adsbygoogle" style="display: block; text-align: center;" data-ad-layout="in-article" data-ad-format="fluid" data-ad-client="ca-pub-2901961548245067" data-ad-slot="9652240186" data-mce-style="display: block; text-align: center;"></ins><br /></p> 
<p><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%3E%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%20%20%20%20%20(adsbygoogle%20%3D%20window.adsbygoogle%20%7C%7C%20%5B%5D).push(%7B%7D)%3B%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row -->
				
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_19 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/11/Beyond-The-Black-Horizons_1.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_37    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_40  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>BEYOND THE BLACK <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript><em> Human</em></h3><h6>Germany | 2020</h6><h6><a href="http://www.beyond-the-black.com/en/" target="_blank" rel="noopener noreferrer" data-mce-href="http://www.beyond-the-black.com/en/">www.beyond-the-black.com</a></h6><ul><li>We bring you some high-quality&nbsp;<strong>gothic metal</strong>. <strong><em>Beyond The Black</em></strong> is a band formed in 2014 that has reached maturity with their&nbsp;<strong>latest record</strong>&nbsp;<strong>“<em>Horizons</em>”</strong>.</li><li>The lead singer, <em>Jennifer Haben, </em>said they have put ‘<em>blood, sweat and tears on it’. </em>You can see it reflected in their theme&nbsp;<em><strong>“Human”</strong></em>&nbsp;and specially in the video<em>.</em></li><li>If you want more, you can see their&nbsp;<a href="https://www.youtube.com/watch?v=OeXEp8hLt1w" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.youtube.com/watch?v=OeXEp8hLt1w">Wacken 2016 concert</a>, the largest Heavy Metal festival in the world 🤘<br data-mce-bogus="1"></li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_38   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_36">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_48 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_41  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_21855"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/xBSZdjqQeOE?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="BEYOND THE BLACK - Human (Official Video) | Napalm Records"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/xBSZdjqQeOE"><meta itemprop="name" content="BEYOND THE BLACK - Human (Official Video) | Napalm Records"><meta itemprop="description" content="Get &quot;Hørizøns&quot; here: https://umg.lnk.to/horizons_ Napalm Online Shop: https://smarturl.it/Horizons-NPR Jennifer Haben on Hørizøns: „More than one year of hard work, blood, sweat and tears was put into this album. Hørizøns became an enormous part of our lives and it’s hard to find the right words to describe what this release means to us. We are more than ready to go and start this new BEYOND THE BLACK journey. This is going to be huge!&quot;"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/xBSZdjqQeOE/0.jpg"><meta itemprop="duration" content="PT5M41S"><meta itemprop="uploadDate" content="2020-06-19T10:55:04Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_37">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_49">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_29  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/3oGbVUl" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_50 et-last-child">
				
				
				<div class="et_pb_module et_pb_code et_pb_code_30  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/2TK049i" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_38">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_51 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_42  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image&nbsp;<a target="_blank" rel="noopener noreferrer">| Beyond The Black Image from Facebook</a></p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_20 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/10/Holly-Humberstone-Falling-Asleep-At-The-Wheel.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_39   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_39">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_52 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_43  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_56835"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/ILPo-HdvfHA?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Holly Humberstone - Falling Asleep At The Wheel (Official Video)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/ILPo-HdvfHA"><meta itemprop="name" content="Holly Humberstone - Falling Asleep At The Wheel (Official Video)"><meta itemprop="description" content="#hollyhumberstone #fallingasleep #fallingasleepatthewheel Falling Asleep At The Wheel out now!! Listen - https://Platoon.lnk.to/faatw https://www.instagram.com/hollyhumberstone https://www.facebook.com/hollyhumberstonemusic/ https://twitter.com/HolHumberstone I wrote this song a while ago whilst still unsure of who I wanted to be and where I wanted to head musically. Writing this song was probably the first time I felt like I knew who I was within the music I was making. The track is about losing momentum and feeling like your emotions will slowly destroy the relationship you’re in and you altogether. I think the dark, wonky sonics define who I am musically, which is why Falling Asleep At The Wheel is such a milestone track for me, and has taught me so much about myself as a musician. We created the song at the house I grew up in, which is very old and falling apart, in the middle of the countryside. You can almost hear the weird sounds of the house within the track. It’s where I feel the most me and love that this is all coming from that one place. Director: Raja Virdi Creative Director: Josh Sanger Script: Josh Sanger &amp; Holly Humberstone Thank you to the Belvoir Estate for the use of their land. A Fifth Sister and Deep End Production Falling Asleep At The Wheel lyrics Oh, you never smoked this much before we met Light up, light up another cigarette I can tell you’re drinking only to forget Don’t know how I got you in such a mess How am I supposed to be your ray of light, your ray of light I get dark sometimes, does it pass you by? I should be your ray of light, your ray of light But I’m falling, falling asleep at the wheel Guess I forgot how to feel Just for a second you’re talking But I’m just pretending you have my attention I’m falling, falling asleep at the wheel I made you think it was real If you think we&#039;re strong enough Come on and wake me up You never looked this tense before we met Back up, back when we were so innocent All this emotion that we&#039;re buried in Tied up, fired up on this adrenaline How am I supposed to be your ray of light, your ray of light Not a cloud in sight, what a perfect night I should be your ray of light, your ray of light But that’s not me And I’m falling, falling asleep at the wheel Guess I forgot how to feel Just for a second you’re talking But I’m just pretending you have my attention I’m falling, falling asleep at the wheel I made you think it was real If you think we&#039;re strong enough Come on and wake me up Wake me up Come on and wake me up. Come on and wake me up If you think we&#039;re strong enough, wake me up And I’m falling, falling asleep at the wheel Guess I forgot how to feel Just for a second you’re talking But I’m just pretending you have my attention I’m falling, falling asleep at the wheel I made you think it was real If you think we&#039;re strong enough Come on and wake me up Wake me up Wake me up, wake me up If you think we&#039;re strong enough Come on and wake me up Wake me up, wake me up"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/ILPo-HdvfHA/0.jpg"><meta itemprop="duration" content="PT3M37S"><meta itemprop="uploadDate" content="2020-03-19T00:00:12Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_40">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_53">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_31  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/3dX8eoe" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_54 et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_32  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/2Tl930y" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_41">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_55 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_44  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Holly Humberstone Image from Facebook</p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_40    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_45  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>HOLLY HUMBERSTONE <img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg"><noscript><img draggable="false" data-mce-resize="false" data-mce-placeholder="1" data-wp-emoji="1" class="emoji" alt="🎙" src="https://s.w.org/images/core/emoji/13.0.0/svg/1f399.svg" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript><em> Falling Asleep At The Wheel</em></h3><h6>UK | 2020</h6><h6><a href="https://twitter.com/HolHumberstone" target="_blank" rel="noopener noreferrer" data-mce-href="https://twitter.com/HolHumberstone">Twitter</a>, <a href="https://www.instagram.com/hollyhumberstone/" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.instagram.com/hollyhumberstone/">Instagram</a>, <a href="https://www.youtube.com/channel/UC0xtJUctDSc7QncZAHYU26g" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.youtube.com/channel/UC0xtJUctDSc7QncZAHYU26g">YouTube</a></h6><ul><li>This young promising British singer became known&nbsp;when she toured with&nbsp;<a href="https://www.youtube.com/watch?v=zABLecsR5UE" target="_blank" rel="noopener noreferrer" data-mce-href="https://www.youtube.com/watch?v=zABLecsR5UE">Lewis Capaldi</a>. She has just released in 2020 her first EP (<em>Extended Play – Short Album</em>) <strong>“Falling Asleep at the Wheel”</strong>.</li><li>Holly Humberstone confessed&nbsp;<em>Apple Music</em>:<br><blockquote><p><em>…I find having conversations really hard, putting things into the context of a song makes it much easier…</em></p></blockquote></li><li>Holly loves adventure stories: <em>The Lord of the Rings, Harry Potter</em>, etc.&nbsp;Don’t be surprised if we see some of that in her next tracks 🔮<br data-mce-bogus="1"></li></ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_21 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/10/Alex-Palomo-1-dia.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_41    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_46  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>ALEX PALOMO 🎙<em> 1 Día (1 Day)</em></h3>
<h6>Spain | 2020</h6>
<h6><a href="https://twitter.com/alexpalomo_" target="_blank" rel="noopener noreferrer">Twitter</a>, <a href="https://www.instagram.com/alexpalomo_/?hl=es" target="_blank" rel="noopener noreferrer">Instagram</a>, <a href="https://www.youtube.com/user/AleeexGuitar" target="_blank" rel="noopener noreferrer">YouTube</a></h6>
<ul>
<li><strong>Alex Palomo is a young Spanish talent</strong> who has learned how to play multiple instruments in a self-taught way. Like the guitar he’s been playing in some bands.</li>
<li>He rose to popularity in <em>The Voice Spain,</em> where <strong><em>Luis Fonsi,</em></strong> said of him:<br />
<blockquote>
<p><em>…I heard magic, a voice with spectacular nuances and something that cannot be taught …</em></p>
</blockquote>
</li>
<li>He has released 2 singles in 2020: <em><a href="https://youtu.be/OiZz3NpddRE" target="_blank" rel="noopener noreferrer">Quema (It Burns)</a></em> and the one we’ve selected for you <strong>“1 día (1 day)”, <span style="color: #e66a05;">a sweet and simple song</span></strong> <strong>that is love at first sight</strong>, you’ll see.</li>
</ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_42   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_42">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_56 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_47  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_75131"  width="1080" height="810"  data-origwidth="1080" data-origheight="810"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/xDiyKopSW0E?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Alex Palomo - 1 Día (Videoclip Oficial)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/xDiyKopSW0E"><meta itemprop="name" content="Alex Palomo - 1 Día (Videoclip Oficial)"><meta itemprop="description" content="Escucha 1 DÍA en todas las plataformas digitales: https://warnermusicspain.lnk.to/AlexPalomo-1Dia Composición, grabación y producción: Alex Palomo Mezcla: Pablo Rouss Mastering: Alex Ferrer (The Groove) ¡Sigue a Alex Palomo en sus redes sociales! Instagram: https://www.instagram.com/alexpalomo_/ Twitter: https://twitter.com/alexpalomo_ Distribuido en exclusiva por WARNER MUSIC SPAIN S.L. LETRA: No sé cuántos días tienen que pasar para irte a buscar. No sé, hoy es un buen día para estar en silencio y sin prisas. Lo sé, sólo queda 1 día, pero aún no supero tu sonrisa. Llevas la primavera metida dentro porqué las flores buscan tu pelo. Te peina el viento y te llora el mar cuando te vas. No sé cuántos días tienen que pasar para irte a buscar. Dame tu silencio, enséñame a volar, apaga el ruido de la ciudad. Espérame otro verano o que venga el invierno de tu mano. Tal vez me queden 5 vidas porqué 2 han sufrido tus caricias. Llevas la primavera metida dentro y cuando llueve me pintas el cielo. Te peina el viento y te llora el mar cuando te vas. No sé cuántos días tienen que pasar para irte a buscar. Dame tu silencio, enséñame a volar, apaga el ruido de la ciudad. Voy a buscarte y luego llevarte dónde nace el bien, dónde muere el mal. Voy a buscarte y luego llevarte a cualquier lugar lejos del final. Ya se apaga el día, se enciende la ciudad y todo vuelve a empezar. #AlexPalomo #1Día"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/xDiyKopSW0E/0.jpg"><meta itemprop="duration" content="PT3M18S"><meta itemprop="uploadDate" content="2020-08-20T22:00:13Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_43">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_57">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_33  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2TqtNnL" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_58 et-last-child">
				
				
				<div class="et_pb_module et_pb_code et_pb_code_34  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/3kGimo5" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_44">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_59 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_48  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image&nbsp;<a target="_blank" rel="noopener noreferrer">| Alex Palomo Image from Instagram</a></p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_22 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/10/Biffy-Clyro-Space_1.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_43   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_45">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_60 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_49  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_52540"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/25HChem_yuU?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Biffy Clyro - Space (Official Video)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/25HChem_yuU"><meta itemprop="name" content="Biffy Clyro - Space (Official Video)"><meta itemprop="description" content="The official video for Biffy Clyro – Space, the latest single taken from &#039;A Celebration of Endings&#039;, you can download it here: http://biffyclyro.co/space Get your copy of &#039;A Celebration of Endings&#039; here: http://biffyclyro.co/acelebrationofendings Director - Joe Connor Producer - Fred Bonham Carter Producer - Andrew Rawson Exec Producer - Alexa Haywood A Just Fred Production Cast - Jasmine Chiu 1st Assistant Director - Chris Kelly DOP - Ruben Woodin Dechamps Underwater Camera - Zac Macaulay Steadicam - Andrew Bainbridge Choreographer - Steven Hoggett Production Design - Luke Moran-Morris Stylist - Robbie Canale Post Production - Black Kite Studios Colourist - George K Subscribe for more content from Biffy Clyro: https://www.youtube.com/user/biffyclyro?sub_confirmation=1 See more Official Videos from Biffy Clyro here: https://www.youtube.com/playlist?list=PLShrpEtlTqC_2-sWJusOTd7Qu_sFR2uhk Follow Biffy Clyro: Instagram - https://www.instagram.com/biffy_clyro Facebook - https://www.facebook.com/biffyclyro Twitter - https://twitter.com/BiffyClyro Website - https://www.biffyclyro.com Lyrics: When we were young and still in love, We didn’t care what we were made of, Our eyes were set on a distant sun. It was shimmering gold. Then slowly one by one, We carried our past and cradled the storm. We tried to conceal the scars we wore. ‘Cause we couldn’t show what we couldn’t show. I get lost sometimes, With you I am found. I get lost so I’ll follow the light to your heart. Will you wait, will you wait for me? There’s always a space in my heart. I’m still caught in your gravity. No matter the distance between us, Our joy lives in the moments we share. Love’s truest meaning lives when you’re not there. Will you wait, will you wait for me? There’s always a space in my heart for you. And then the silence fell. We bit our tongues, with which we tell. All of our dreams,and the stories we sell, But we didn’t know what we didn’t know. I get lost sometimes, With you I am found. I get lost so I’ll follow the light to your heart. Will you wait, will you wait for me? There’s always a space in my heart. I’m still caught in your gravity. No matter the distance between us. Our joy lives in the moments we share. Love’s truest meaning lives when you’re not there. Will you wait, will you wait for me? There’s always a space in my heart for you. The official YouTube channel of Biffy Clyro. Biffy Clyro&#039;s biography begins in Scotland starting in 1995. Their lineup has stayed consistent for the duration of their activity, with Simon Neil on guitar, James Johnston playing bass, and Ben Johnston handling drums. Simon Neil serves as the primary vocalist and lyricist, but all three have participated with vocals and songwriting. Over the course of their previous seven albums, Biffy Clyro have topped the charts, headlined numerous huge festivals, performed all over the globe, including tours with Linkin Park, Queens of the Stone Age, and Muse and earned countless awards. Biffy Clyro’s biggest hits include “Many of Horror (When We Collide)”, “Bubbles”, “Black Chandelier”, “Biblical”, “Re-arrange” and “Mountains”. The iconic Biffy Clyro catalogue also includes the albums “Blackened Sky”, “The Vertigo of Bliss”, “Puzzle”, “Only Revolutions”, “Opposites” and “Ellipsis”. Subscribe to the Biffy Clyro channel for all the best and latest official music videos, official audio, albums, behind the scenes and live performances. #BiffyClyro #Space #ACelebrationOfEndings"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/25HChem_yuU/0.jpg"><meta itemprop="duration" content="PT4M23S"><meta itemprop="uploadDate" content="2020-08-19T13:00:11Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_46">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_61">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_35  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2Hf68Um" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_62 et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_36  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/3nZ3hjk" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_47">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_63 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_50  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Biffy Clyro Image from Facebook</p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_44    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_51  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>BIFFY CLYRO 🎙 Space</h3>
<h6 style="text-align: left;">UK | 2020</h6>
<h6 style="text-align: left;"><a href="https://www.biffyclyro.com/" target="_blank" rel="noopener noreferrer">www.biffyclyro.com</a></h6>
<ul>
<li><strong>Biffy Clyro</strong>, a Scottish group formed in 1995, releases their 8th album, “<em>A Celebration Of Endings</em>”. From powerful songs like “<em>Instant History</em>” to this <strong>wonderful ballad “<em>Space</em>”</strong>, this record is full of great music.</li>
<li>Biffy Clyro also featured on the UK COVID-19 benefit single that we talk about in “<a href="https://trembol.com/en/dave-grohl-times-like-these-foo-fighters-song/" target="_blank" rel="noopener noreferrer"><strong>Foo Fighters <em>Times Like These</em></strong></a>”.</li>
<li><strong>If you did not know the group, now is time</strong> 😊</li>
</ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_23 et_section_regular" >
				
				
				
				
					<div class="et_pb_row et_pb_row_11">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_45  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_37  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%20async%20src%3D%22https%3A%2F%2Fpagead2.googlesyndication.com%2Fpagead%2Fjs%2Fadsbygoogle.js%22%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></p> 
<p><ins class="adsbygoogle" style="display: block; text-align: center;" data-ad-layout="in-article" data-ad-format="fluid" data-ad-client="ca-pub-2901961548245067" data-ad-slot="9652240186" data-mce-style="display: block; text-align: center;"></ins><br /></p> 
<p><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%3E%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%20%20%20%20%20(adsbygoogle%20%3D%20window.adsbygoogle%20%7C%7C%20%5B%5D).push(%7B%7D)%3B%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row -->
				
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_24 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/10/Of-Monsters-and-Man.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_46    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_52  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>OF MONSTERS AND MEN 🎙<em> Visitor</em></h3>
<h6>Island | 2020</h6>
<h6><a href="https://www.ofmonstersandmen.com" target="_blank" rel="noopener noreferrer">www.ofmonstersandmen.com</a></h6>
<ul>
<li>Surely you know this Icelandic indie-pop band, because of their <strong>worldwide hit “<em><a href="https://www.youtube.com/watch?v=ghb6eDopW8I" target="_blank" rel="noopener noreferrer">Little Talks</a></em>”</strong>.</li>
<li><strong>They have already completed 10 years in music</strong>. To celebrate it they have released this brilliant song, “<em>Visitor</em>”, which they recorded just before the pandemic. February in Iceland, they must have been cold ☃!</li>
<li><strong>The song talks about looking at ourselves from the outside in a moment of radical change.</strong></li>
</ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_47   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_48">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_64 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_53  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_80617"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/Bq1lpEC70Hg?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Of Monsters and Men - Visitor (Official Music Video)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/Bq1lpEC70Hg"><meta itemprop="name" content="Of Monsters and Men - Visitor (Official Music Video)"><meta itemprop="description" content="►Listen to &quot;Visitor&quot;: https://OMAM.lnk.to/VisitorVD ►Exclusive Merch: https://www.ofmonstersandmenofficialm... ►Follow Of Monsters and Men Online Instagram: https://www.instagram.com/ofmonstersa... Facebook: https://www.facebook.com/ofmonstersan... Twitter: https://twitter.com/monstersandmen Website: http://www.ofmonstersandmen.com Video Director - Thora Hilmarsdottir Video Producer - Kristin Andrea Thordardottir Video Editor - Gudlaugur Andri Eythorsson Cinematographer - Thor Eliasson AD - Siggi Kjartan 1st AC - Gudjon Hrafn Gudmundsson Gaffer - Siggi Bahama Key Grip - Jon Andri Gudmundsson Production Designer - Steinn Einar Jonsson Costume Designer - Sylvia Lovetank Hair and MakeupDesigner - Isak Freyr Helgason Choreography - Stella Rosenkranz Stunt Coordinator - Jon Vidar Arnthorsson Sound design - Lydia Gretarsdottir VFX - Henrik Linnet Online &amp; Color Grading - Luis Ascanio / Trickshot Equipment Rental - Kukl Location Facility - NNW Production Company - Skot Productions Featured Actors - Ingvar E. Sigurdsson, Haraldur Ari Stefansson Stunt Double - Arnar Orri Arnarsson #OfMonstersandMen #Visitor"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/Bq1lpEC70Hg/0.jpg"><meta itemprop="duration" content="PT3M48S"><meta itemprop="uploadDate" content="2020-09-09T16:00:10Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_49">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_65">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_38  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2Fkwd3T" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_66 et-last-child">
				
				
				<div class="et_pb_module et_pb_code et_pb_code_39  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/2GLCMNy" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_50">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_67 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_54  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image&nbsp;<a target="_blank" rel="noopener noreferrer">| Of Monsters and Man Image from Facebook</a></p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_25 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg et_pb_parallax_css"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/10/Musica-3.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_48   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_51">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_68 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_55  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_45499"  width="1080" height="810"  data-origwidth="1080" data-origheight="810"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/o_COa_UAgsk?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Sunrise (Edit)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/o_COa_UAgsk"><meta itemprop="name" content="Sunrise (Edit)"><meta itemprop="description" content="Provided to YouTube by Universal Music Group Sunrise (Edit) · Movin Sunrise ℗ 2020 Xploded Music Limited Released on: 2020-02-07 Associated Performer, Vocals: Kristen Cummings Producer: Nathan Belton Composer Lyricist: Gary John Deadman Composer Lyricist: Joshua Fredrick Powell Composer Lyricist: Christopher William Composer Lyricist: Per Olof Ljungqvist Composer Lyricist: Kristen Cummings Composer Lyricist: Kevin Mark Andrews Auto-generated by YouTube."><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/o_COa_UAgsk/0.jpg"><meta itemprop="duration" content="PT3M19S"><meta itemprop="uploadDate" content="2020-02-06T10:25:19Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_52">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_69">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_40  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/34sBRt4" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_70 et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_41  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/2EZ9pGA" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_53">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_71 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_56  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Photo by <a href="https://unsplash.com/@sgabriel?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText" rel="nofollow noopener noreferrer" target="_blank" data-mce-href="https://unsplash.com/@sgabriel?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Sebastien Gabriel</a> on <a href="https://unsplash.com/s/photos/sunrise?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText" rel="nofollow noopener noreferrer" target="_blank" data-mce-href="https://unsplash.com/s/photos/sunrise?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_49    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_57  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>MOVIN 🎙 Sunrise</h3>
<h6 style="text-align: left;">UK | 2020</h6>
<h6 style="text-align: left;"><a href="https://soundcloud.com/nathan-movin-belton" target="_blank" rel="noopener">https://soundcloud.com/nathan-movin-belton</a></h6>
<ul>
<li><strong>Have you ever listened to a “Makina” song?</strong> It’s a Spanish blend of happy hardcore. Electronic music that is fast and bouncy. It’s also extremely popular in the North of England and Scotland.</li>
<li><strong>The British Nath Belton is the name behind Movin. A great tune with a happy melody that is bound to make you dance. Thrill, how we like it!</strong></li>
<li>The song is used in a <a href="https://www.tiktok.com/music/Movin-Sunrise-DeV1Se-Edit-6821649954554039045?lang=en" target="_blank" rel="nofollow noopener noreferrer"><strong>new TikTok viral challenge</strong></a>.</li>
</ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_26 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/10/Der-Astronaut-Back-to-the-moon_1.jpeg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_50    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_58  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>DER ASTRONAUT 🎙 Back to the Moon</h3>
<h6>Germany | 2020</h6>
<h6><a href="https://www.maxmutzke.de/" target="_blank" rel="noopener">www.maxmutzke.de</a></h6>
<ul>
<li>There are really weird shows on TV, but “<em><a href="https://www.youtube.com/channel/UCj-EBDViG3vi0LQla6SLueg" target="_blank" rel="noopener noreferrer">The Mask Singer</a></em>” takes the cake. Popular artists sing with a mask and the audience votes for their favourite. <strong>Der Astronaut</strong> won in 2019.</li>
<li>The astronaut is the <strong>German singer Max Mutzke</strong>, who has released this awesome single. <strong>Max took part in Eurovision 2004</strong> with the song <em><a href="https://www.youtube.com/watch?v=j6jSUb_RvXM" target="_blank" rel="noopener noreferrer">Can’t Wait Until Tonight</a></em>.</li>
<li>Other famous masked singers, of which we talk about in Trembol are <strong><a href="https://trembol.com/en/k319-alan-walker-ignite-ft-julie-bergan-seungri/" target="_blank" rel="noopener noreferrer">K-391 and Alan Walker</a>.</strong></li>
</ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_51   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_54">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_72 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_59  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_72543"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/_xaOatg6D1U?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Der Astronaut - Back To The Moon (Official Video)"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/_xaOatg6D1U"><meta itemprop="name" content="Der Astronaut - Back To The Moon (Official Video)"><meta itemprop="description" content="Seht hier das offizielle Musikvideo zu &quot;Back To The Moon&quot; vom Astronauten! Die Single &quot;Back To The Moon&quot; jetzt überall streamen: http://umg.lnk.to/BackToTheMoon Der Astronaut hat bereits 2019 als Gewinner der ersten deutschen MaskedSinger Staffel Geschichte geschrieben. Nun trat er beim diesjährigen FreeESC auf Pro7 für den Mond an und sang sich erneut in die Herzen der Zuschauer. Der Song, der extra für die Show neu geschrieben wurde, stammt von Justin Balk und Max Mutzke Folgt Max Mutzke: ➔Instagram: https://www.instagram.com/max_mutzke_... ➔Facebook: https://www.facebook.com/maxmutzkemusik Lyrik-Video: https://www.youtube.com/watch?v=lFgS97ArY4M Music video by Der Astronaut performing Back To The Moon. © 2020 Max Mutzke, under exclusive license to Universal Music GmbH http://vevo.ly/3ELIxH"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/_xaOatg6D1U/0.jpg"><meta itemprop="duration" content="PT3M23S"><meta itemprop="uploadDate" content="2020-05-27T16:00:54Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_55">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_73">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_42  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/2RXB5i3" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_74 et-last-child">
				
				
				<div class="et_pb_module et_pb_code et_pb_code_43  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/3334HAS" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_56">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_75 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_60  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image Der Astronaut Website</p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_27 et_pb_section_parallax et_pb_with_background et_section_specialty" >
				
				<div class="et_parallax_bg_wrap"><div
						class="et_parallax_bg_phone_exist et_parallax_bg_tablet_exist et_parallax_bg"
						style="background-image: url(https://trembol.com/wp-content/uploads/2020/10/Miley-Cyrus-Midnight-Sky-1.jpg);"
					></div></div>
				
				<div class="et_pb_row">
					<div class="et_pb_column et_pb_column_1_2 et_pb_column_52   et_pb_specialty_column  et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_row_inner et_pb_row_inner_57">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_76 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_61  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_68330"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/2pNZIvhiBjY?enablejsapi=1&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&" class="__youtube_prefs__  no-lazyload" title="Miley Cyrus - Midnight Sky | 2020 Video Music Awards"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div><span itemprop="video" itemscope itemtype="http://schema.org/VideoObject"><meta itemprop="embedUrl" content="https://www.youtube.com/embed/2pNZIvhiBjY"><meta itemprop="name" content="Miley Cyrus - Midnight Sky | 2020 Video Music Awards"><meta itemprop="description" content="Miley’s New Album Plastic Hearts is Available Now: https://mileyl.ink/PlasticHearts Miley’s new single “Midnight Sky” is available now: http://mileyl.ink/midnightsky iTunes: http://mileyl.ink/midnightsky/itunes Apple Music: http://mileyl.ink/midnightsky/applemusic Spotify: http://mileyl.ink/midnightsky/spotify Amazon: http://mileyl.ink/midnightsky/az Deezer: http://mileyl.ink/midnightsky/deezer Watch the Official Music Video, Self-Directed by Miley Cyrus http://mileyl.ink/midnightsky/youtube View merch at Miley’s official store now! https://smarturl.it/MileyStore?iQid=yt Follow Miley on Spotify, Apple Music or Deezer to get new music as soon as it’s out: https://smarturl.it/FollowMC?iQid=yt Connect with Miley Facebook: https://mileyl.ink/facebook Twitter: https://mileyl.ink/twitter Instagram: https://mileyl.ink/instagram Snapchat: https://mileyl.ink/snapchat Tiktok: https://mileyl.ink/tiktok Site: http://www.mileycyrus.com LYRICS: La la la la la Yeah it’s been a long night and the mirror’s telling me to go home But it’s been a long time since I felt this good on my own A lot of years went by with my hands tied up in your ropes Forever, and ever, no more The midnight sky is the road I’m taking Head high up in the clouds Ohhhh I was born to run I don’t belong to anyone, oh no I don’t need to be loved by you Fire in my lungs can’t bite the devil on my tongue, oh no I don’t need to be loved by you See my lips, on her mouth, everybody’s talking now baby Ohh, you know it’s true, yeahh That I was born to run I don’t belong to anyone, oh no I don’t need to be loved by you Loved by you…. La la la la la She got her hair pulled back cause the sweat’s dripping off of her face Said it ain’t so bad if I wanna make a couple mistakes You should know right now that I never stay put in one place Forever, and ever, no more The midnight sky is the road I’m taking Head high up in the clouds Ohhhh I was born to run I don’t belong to anyone, oh no I don’t need to be loved by you Fire in my lungs can’t bite the devil on my tongue, oh no I don’t need to be loved by you See my lips, on her mouth, everybody’s talking now baby Ohh, you know it’s true, yeahhh That I was born to run I don’t belong to anyone, oh no I don’t need to be loved by you By you…. Ohhh I don’t hide, blurry eyes like you Like you I was born to run I don’t belong to anyone, oh no I don’t need to be loved by you Fire in my lungs can’t bite the devil on my tongue, you know I don’t need to be loved by you See his hands round my waist, thought you’d never be replaced baby Ohh you know it’s true, yeah That I was born to run I don’t belong to anyone, oh no I don’t need to be loved by you Yeah… La la la la la la la #MileyCyrus #MidnightSky #VMAs #SheIsComing #Pop"><meta itemprop="thumbnailUrl" content="https://i.ytimg.com/vi/2pNZIvhiBjY/0.jpg"><meta itemprop="duration" content="PT4M2S"><meta itemprop="uploadDate" content="2020-09-08T23:05:18Z"></span></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_58">
				<div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_77">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_44  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://amzn.to/3csBfrc" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img src="data:image/svg+xml,%3Csvg%20xmlns='http://www.w3.org/2000/svg'%20viewBox='0%200%200%200'%3E%3C/svg%3E" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;" data-lazy-src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png"><noscript><img src="https://trembol.com/wp-content/uploads/2020/06/available_at_amazon_en_horizontal_wht.png" alt="Botón para comprar la canción en Amazon" title="☝ SPECIAL EDITION 【BEST SONGS 2020】 THE 53 &#039;EMOTIONS OF THE WEEK&#039;"></noscript>
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_4 et_pb_column_inner et_pb_column_inner_78 et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_45  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><a href="https://apple.co/2ExB7Kl" target="_blank" rel="nofollow noreferrer noopener">
<span class="et_pb_image_wrap ">
<img srcset="https://trembol.com/wp-content/uploads/2020/06/US_UK_iTunes_Store_Get_Solid_Lockup_RGB_wht_012618.svg 1w"  alt="Botón para comprar la canción en iTunes Store">
</span>
</a></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner --><div class="et_pb_row_inner et_pb_row_inner_59">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_inner et_pb_column_inner_79 et-last-child">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_62  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p>Background Image Miley Cyrus Photo Facebook</p></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row_inner -->
			</div> <!-- .et_pb_column --><div class="et_pb_column et_pb_column_1_2 et_pb_column_53    et_pb_css_mix_blend_mode_passthrough">
				
				
				<div class="et_pb_module et_pb_text et_pb_text_63  et_pb_text_align_justified et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><h3>MILEY CYRUS 🎙 Midnight Sky</h3>
<h6>USA | 2020</h6>
<h6><a href="http://www.mileymidnightsky.com" target="_blank" rel="noopener noreferrer">www.mileymidnightsky.com</a></h6>
<ul>
<li><strong>80s are back, </strong>that’s great news for a music industry riddle with reggaeton.</li>
<li><strong>Miley Cyrus <em>Midnight Sky</em> live show </strong>in 2020 MTV VMAs (Video Music Awards) is the happy proof.</li>
<li>Furthermore <strong><a href="https://trembol.com/en/starboy-the-weeknd-albums/the-weeknd-blinding-lights/">The Weeknd</a></strong> or <strong><a href="https://trembol.com/en/playlist-hits-all-time-number-ones/#descubre">Dua Lipa</a></strong> are fostering that trend, the same as 80s mythical bands like <strong><a href="https://trembol.com/en/abc-band-martin-fry-viva-love/">ABC</a>, </strong>that have return with new and fantastic material.</li>
<li><strong>Miley Cyrus joined Dua Lipa</strong> at the end of 2020 to give us another hit “<a href="https://www.youtube.com/watch?v=0ir1qkPXPVM" target="_blank" rel="noopener noreferrer"><em>Prisioner</em></a>”</li>
</ul></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				</div> <!-- .et_pb_row -->
				
			</div> <!-- .et_pb_section --><div class="et_pb_section et_pb_section_28 et_section_regular" >
				
				
				
				
					<div class="et_pb_row et_pb_row_12">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_54  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_46  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%20async%20src%3D%22https%3A%2F%2Fpagead2.googlesyndication.com%2Fpagead%2Fjs%2Fadsbygoogle.js%22%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></p> 
<p><ins class="adsbygoogle" style="display: block; text-align: center;" data-ad-layout="in-article" data-ad-format="fluid" data-ad-client="ca-pub-2901961548245067" data-ad-slot="9652240186" data-mce-style="display: block; text-align: center;"></ins><br /></p> 
<p><img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%3E%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%20%20%20%20%20(adsbygoogle%20%3D%20window.adsbygoogle%20%7C%7C%20%5B%5D).push(%7B%7D)%3B%3C!--%20%5Bet_pb_line_break_holder%5D%20--%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="<script>" title="<script>"></div>
			</div> <!-- .et_pb_code -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row -->
				
				
			</div> <!-- .et_pb_section --><div id="video-playlist" class="et_pb_section et_pb_section_29 et_pb_section_parallax et_pb_with_background et_section_regular" >
				
				<div class="et_parallax_bg_wrap"><div data-bg="https://trembol.com/wp-content/uploads/2020/04/business_02.jpg"
						class="et_parallax_bg rocket-lazyload"
						style=""
					></div></div>
				
				
					<div class="et_pb_with_border et_pb_row et_pb_row_13">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_55  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_blurb et_pb_blurb_5 et_animated  et_pb_text_align_center  et_pb_blurb_position_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_blurb_content">
					<div class="et_pb_main_blurb_image"><span class="et_pb_image_wrap"><span class="et-waypoint et_pb_animation_off et-pb-icon">&#xe0a3;</span></span></div>
					<div class="et_pb_blurb_container">
						
						<div class="et_pb_blurb_description"><p>YouTube Playlist Best Songs 2020 📺</p></div>
					</div>
				</div> <!-- .et_pb_blurb_content -->
			</div> <!-- .et_pb_blurb -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row -->
				
				
			</div> <!-- .et_pb_section --><div class="et_pb_with_border et_pb_section et_pb_section_30 et_section_regular" >
				
				
				
				
					<div class="et_pb_row et_pb_row_14">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_56  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_text et_pb_text_64 et_clickable  et_pb_text_align_center et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><p><em>In some mobile device YouTube doesn't move to the next song automatically, if it is your case and you want to listen to the playlist straight, visit <strong><a href="https://www.youtube.com/watch?v=xDiyKopSW0E&amp;list=PL0sK1MVB2F7Aq_WuOUFMp-oVmHYgU90av" target="_blank" rel="noopener noreferrer">Trembol YouTube Channel</a></strong></em></p></div>
			</div> <!-- .et_pb_text --><div class="et_pb_with_border et_pb_module et_pb_text et_pb_text_65  et_pb_text_align_left et_pb_bg_layout_light">
				
				
				<div class="et_pb_text_inner"><div class="epyt-video-wrapper"><iframe  data-ep-a="slideInRight"  id="_ytid_97910"  width="1080" height="608"  data-origwidth="1080" data-origheight="608"  data-relstop="1" data-ep-src="https://www.youtube.com/embed/?enablejsapi=1&listType=playlist&list=PL0sK1MVB2F7Aq_WuOUFMp-oVmHYgU90av&rel=0&modestbranding=1&autoplay=0&cc_load_policy=1&cc_lang_pref=&iv_load_policy=3&loop=0&fs=1&playsinline=1&autohide=2&hl=es_ES&theme=dark&color=red&controls=1&index=0&" class="__youtube_prefs__  no-lazyload" title="2020 🥇 Las Mejores Canciones | The Best Songs 😍"  allow="autoplay; encrypted-media" allowfullscreen data-no-lazy="1" data-skipgform_ajax_framebjll=""></iframe></div></div>
			</div> <!-- .et_pb_text -->
			</div> <!-- .et_pb_column -->
				
				
			</div> <!-- .et_pb_row --><div class="et_pb_row et_pb_row_15">
				<div class="et_pb_column et_pb_column_4_4 et_pb_column_57  et_pb_css_mix_blend_mode_passthrough et-last-child">
				
				
				<div class="et_pb_with_border et_pb_module et_pb_code et_pb_code_47  et_pb_text_align_center">
				
				
				<div class="et_pb_code_inner"><script async src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js">' ></script>
<ins class=

    Spotify Playlist Best Songs 2020 🎧

    Remember, to listen to the playlist you need a free Spotify account

    best songs 2020
    best songs 2020

    Tell us, did you miss any song? Which did you like best? We are listening 🙉

    0 Comments

    Submit a Comment

    Your email address will not be published. Required fields are marked *