<p>4U for you Nourishment Mask<BR><BR>Výživná a ochranná maska je obohacená silikonovým komplexem, keratinem a rostlinnými výtažky, které chrání strukturu vlasů vůči vnějším vlivům, dodávají lesk a elasticitu. Její složení efektivně stabilizuje ph. Vlasy se výborně tvarují a lehce se rozčesávají.<BR><BR><STRONG>SHE by SO.CAP</STRONG>.<STRONG> <BR></STRONG>Pečuje o ženskou krásu v každém svém kroku a z těchto důvodů nabízí širokou řadu specifických výrobků určených k péči o prodloužené vlasy, účinná a vlastní kosmetická ošetření garantovaná výzkumem SO.CAP.&nbsp; <BR><BR>Snem mnohých žen je mít krásné, dlouhé, husté a zdravé vlasy. Ne každé z nás se tento sen splnil, protože vlasy dlouho rostou a jsou vystavovány každodennímu opotřebení. Jsme rádi, že máte možnost tuto dobu překlenout a splnit si svůj sen. Vlasové prameny Vám byly aplikovány keratinovou metodou u odborně zaškoleného kadeřníka s certifikátem SHE by SO.CAP. Jsou to 100 % přírodní vlasy. Cílem prodlužování vlasů je dodat Vašim vlasům hustotu a délku a to téměř neviditelným efektem. Tyto vlasy vyžadují pravidelnou péči a proto Vám doporučujeme návod jak se o prodloužené vlasy starat. <BR><BR><STRONG>Umývání vlasů</STRONG> - vlasy si umývejte jemně, nejlépe pod sprchou. Na ošetření i v případě suchých vlasů se sklonem k lámání používejte jen profesionální vlasovou kosmetiku SHE by SO.CAP. FOR YOU /4U/. Po každém umytí šamponem FOR YOU /4U/ je nutné použít masku z této řady, která má působit 5–10 min. <BR><BR><STRONG>Sušení a česání vlasů</STRONG> - vlasy vysušte ručníkem, až potom jemně pročešte vlasy kartáčem SHE by SO.CAP. Je nutné vlasy pročesat nad keratinovým spojem i jeho celé délce až ke konečkům. Vlasy se oddělte do malých sekcí a rozčesávání věnujte velkou pozornost. Když si rozčesáváte konce vlasů, musíte si je přichytit druhou rukou. V opačném případě se Vám vlasy zacuchají a budou s namáhat a vypadávat. Minimálně 2x denně si vlasy pročešte a aplikujte regenerační spray FOR YOU /4U/. <BR><BR><STRONG>Chemické ošetření pramenů a úprava -</STRONG>&nbsp;barvení provádějte výlučně v kadeřnických salonech. Prameny se můžou ztmavovat, nesmí se odbarvovat ani melírovat. Nedoporučujeme aplikovat trvalou. Můžete používat všechny druhy stylingu, vlasy můžete žehlit, natáčet, kulmovat a foukat (teplý zdroj nesmí přijít do styku s keratinovými destičkami. Doporučujeme konce vlasů pravidelně zastřihávat. <BR><BR><STRONG>Spánek</STRONG> - vlasy si během spánku svažte do volné gumičky nebo je vhodně zapleťte do culíku. Zabráníte tak tahání vlasů a nabudou Vám vadit. <BR><BR><STRONG>Péče o vlasy ve volném čase</STRONG> - na dovolené u moře potřebují vlasy zvýšenou péči. Po každém umytí použijte masku a spray. Do konečků intenzivně nanášejte ochranný fluid FOR YOU /4U/.</p>