Quetiapine Fair-Med tabletki powlekane | 200 mg | 90 tabl.

<p>1  </p><p>Ulotka dołączona do opakowania: informacja dla użytkownika  </p><p>Quetiapine Fair-Med, 25 mg, tabletki powlekane </p><p>Quetiapine Fair-Med, 100 mg, tabletki powlekane </p><p>Quetiapine Fair-Med, 150 mg, tabletki powlekane </p><p>Quetiapine Fair-Med, 200 mg, tabletki powlekane </p><p>Quetiapine Fair-Med, 300 mg, tabletki powlekane quetiapinum  </p><p>Należy zapoznać się z treścią ulotki przed zażyciem leku, ponieważ zawiera ona informacje ważne dla pacjenta. </p><p>- Należy zachować tę ulotkę, aby w razie potrzeby móc ją ponownie przeczytać. </p><p>- W razie jakichkolwiek wątpliwości, należy zwrócić się do lekarza, farmaceuty lub pielęgniarki - Lek ten przepisano ściśle określonej osobie. Nie należy go przekazywać innym. </p><p>- Lek może zaszkodzić innej osobie, nawet jeśli objawy jej choroby są takie same. </p><p>- Jeśli u pacjenta wystąpią jakiekolwiek objawy niepożądane, w tym wszelkie objawy niepożądane niewymienione w ulotce, należy powiedzieć o tym lekarzowi lub farmaceucie. Patrz punkt 4. </p><p> </p><p>Spis treści ulotki: </p><p>1. Co to jest lek Quetiapine Fair-Med i w jakim celu się go stosuje </p><p>2. Informacje ważne przed przyjęciem leku Quetiapine Fair-Med </p><p>3. Jak przyjmować lek Quetiapine Fair-Med </p><p>4. Możliwe działania niepożądane </p><p>5. Jak przechowywać lek Quetiapine Fair-Med </p><p>6. Zawartość opakowania i inne informacje  </p><p>1. Co to jest lek Quetiapine Fair-Med i w jakim celu się go stosuje  </p><p>Lek Quetiapine Fair-Med zawiera substancję nazywaną kwetiapiną. Należy ona do grupy leków przeciwpsychotycznych. Lek Quetiapine Fair-Med może być stosowany w leczeniu chorób, takich jak: </p><p>  epizody depresyjne w przebiegu choroby afektywnej dwubiegunowej, kiedy pacjent odczuwa smutek, depresję, brak energii, utratę apetytu, ma poczucie winy lub nie może spać;</p><p> mania, kiedy pacjent jest bardzo silnie podekscytowany, podniecony, pobudzony, pełen entuzjazmu lub nadmiernie aktywny, albo ma zaburzoną zdolność krytycznej oceny, jest agresywny lub uciążliwy;  schizofrenia, kiedy pacjent słyszy lub odczuwa nieistniejące głosy i rzeczy, ma zwidy lub jest nadmiernie podejrzliwy, zlękniony, zdezorientowany, ma poczucie winy, napięcia lub depresji. </p><p> </p><p>Lekarz może zalecić dalsze stosowanie leku Quetiapine Fair-Med, nawet jeśli stan pacjenta ulegnie poprawie. </p><p>  </p><p>2. Informacje ważne przed przyjęciem leku Quetiapine Fair-Med </p><p>Kiedy nie przyjmować leku Quetiapine Fair-Med: </p><p>  jeśli pacjent ma uczulenie na substancję czynną lub którykolwiek z pozostałych </p><p>2 składników tego leku (wymienionych w punkcie 6)  jeśli pacjent przyjmuje jednocześnie którykolwiek z następujących leków: </p><p>- niektóre leki stosowane w zakażeniu wirusem HIV - leki z grupy azoli (stosowane w zakażeniach grzybiczych), - erytromycynę lub klarytromycynę (stosowane w zakażeniach) - nefazodon (stosowany w leczeniu depresji). </p><p> </p><p>Jeżeli którakolwiek z wymienionych powyżej sytuacji dotyczy pacjenta, nie należy stosować leku </p><p>Quetiapine Fair-Med. W razie wątpliwości należy poradzić się lekarza lub farmaceuty przed zastosowaniem leku Quetiapine Fair-Med. </p><p> </p><p>Ostrzeżenia i środki ostrożności </p><p>Przed rozpoczęciem przyjmowania leku Quetiapine Fair-Med należy poinformować lekarza lub farmaceutę, jeśli: </p><p>  u pacjenta lub u kogoś w jego rodzinie występują lub występowały jakiekolwiek problemy z sercem, np. zaburzenia rytmu serca, osłabienie mięśnia sercowego lub zapalenie mięśnia sercowego lub jeśli pacjent stosuje jakiekolwiek leki, które mogą mieć wpływ na rytm serca  pacjent ma niskie ciśnienie krwi  pacjent przebył udar mózgu, szczególnie jeśli jest w podeszłym wieku  u pacjenta występują problemy z wątrobą  u pacjenta kiedykolwiek wystąpił napad drgawek (padaczka)  pacjent ma cukrzycę lub zwiększone ryzyko zachorowania na cukrzycę; w takim przypadku lekarz może zalecić badania stężenia cukru we krwi podczas stosowania leku Quetiapine Fair-Med  kiedykolwiek stwierdzono u pacjenta małą liczbę białych krwinek (bez względu na to, czy było to spowodowane przyjmowaniem innych leków czy nie)  pacjent jest osobą w podeszłym wieku z otępieniem starczym (ograniczenie sprawności pracy mózgu); osoba taka nie powinna stosować leku Quetiapine Fair-</p><p>Med, ponieważ leki z grupy, do której należy lek Quetiapine Fair-Med, mogą zwiększać ryzyko udaru, a w niektórych przypadkach ryzyko śmierci u osób w podeszłym wieku z otępieniem starczym  jeśli pacjent jest osobą w podeszłym wieku z chorobą Parkinsona / parkinsonizmem  u pacjenta lub członka jego rodziny stwierdzono kiedyś wystąpienie zakrzepów gdyż stosowanie leków z tej grupy było związane z powstawaniem zakrzepów  pacjent ma lub miał w przeszłości stany krótkotrwałego zatrzymania oddechu podczas nocnego snu („bezdech senny”) oraz w razie stosowania leków powodujących spowolnienie aktywności mózgu („depresanty”)  pacjent ma lub miał w przeszłości stan w którym nie można całkowicie opróżnić pęcherza moczowego (zatrzymanie moczu), ma powiększoną prostatę, niedrożność jelit lub zwiększone ciśnienie wewnątrz oka. Te objawy czasami są spowodowane przez leki (tzw. leki przeciwcholinergiczne), które wpływają na funkcjonowanie komórek nerwowych, stosowane w leczeniu niektórych chorób  pacjent w przeszłości nadużywał alkoholu lub leków  </p><p>Należy niezwłocznie poinformować lekarza, jeżeli po przyjęciu leku Quetiapine Fair-Med wystąpi którykolwiek z następujących objawów: </p><p> połączenie gorączki, silnego zesztywnienia mięśni, obfitych potów lub obniżenia poziomu świadomości (choroba zwana złośliwym zespołem neuroleptycznym). </p><p>Może być potrzebna natychmiastowa pomoc medyczna  mimowolne ruchy, przede wszystkim mięśni twarzy lub języka </p><p>3  zawroty głowy lub uczucie bardzo nasilonej senności. Może to zwiększać ryzyko przypadkowych urazów (upadki) u pacjentów w podeszłym wieku  atak padaczkowy (drgawki)  długotrwała i bolesna erekcja (priapizm)  szybkie i nieregularne bicie serca, nawet podczas odpoczynku, kołatanie serca, trudności z oddychaniem, ból w klatce piersiowej lub niewyjaśnione zmęczenie. </p><p>Lekarz będzie musiał zbadać serce i jeśli to konieczne, natychmiast skierować pacjenta do kardiologa. </p><p>Wszystkie te objawy mogą być spowodowane działaniem tego typu leków. </p><p>Należy niezwłocznie poinformować lekarza jeżeli u pacjenta wystąpi: </p><p> gorączka, objawy grypopodobne, ból gardła lub jakiekolwiek inne zakażenie, jako że może to być następstwem bardzo małej liczby krwinek białych we krwi, w związku z czym może być konieczne przerwanie stosowania leku Quetiapine Fair-</p><p>Med i (lub) zastosowanie odpowiedniego leczenia  zaparcie łącznie z utrzymującym się bólem brzucha lub zaparcie, które nie ustępuje imo leczenia, jako że może to prowadzić do bardziej poważnej blokady jelit  </p><p>Myśli samobójcze i nasilenie się depresji </p><p>Pacjenci z depresją mogą czasami mieć myśli o samookaleczeniu lub o popełnieniu samobójstwa. </p><p>Mogą się one nasilać na samym początku leczenia, ponieważ leki te zaczynają działać zazwyczaj po upływie 2 tygodni, a czasem później. Myśli te mogą się również nasilić jeśli pacjent nagle przerwie przyjmowanie leku. Wystąpienie tego rodzaju myśli jest bardziej prawdopodobne, jeżeli pacjent jest młodym dorosłym. Dane z badań klinicznych wskazują na zwiększone ryzyko wystąpienia myśli i (lub) zachowań samobójczych u młodych dorosłych w wieku poniżej 25 lat, z depresją. </p><p> </p><p>Jeśli u pacjenta występują myśli samobójcze lub myśli o samookaleczeniu, należy niezwłocznie skontaktować się z lekarzem lub zgłosić się do szpitala. Pomocne może okazać się poinformowanie krewnych lub przyjaciół o depresji oraz poproszenie ich o przeczytanie tej ulotki. Pacjent może zwrócić się o pomoc do krewnych lub przyjaciół i prosić o informowanie go, jeśli zauważą, że depresja lub lęk nasiliły się lub wystąpiły niepokojące zmiany w zachowaniu pacjenta. </p><p> </p><p>Wysypka z eozynofilią i objawami układowymi (DRESS) </p><p>Rozległa wysypka, wysoka temperatura ciała, zwiększona aktywność enzymów wątrobowych, zaburzenia krwi (eozynofilia), powiększenie węzłów chłonnych i zajęcie innych narządów (wysypka z eozynofilią i objawami układowymi jest znana również jako DRESS lub zespół nadwrażliwości na lek). Jeśli u pacjenta wystąpią te objawy, należy przerwać stosowanie leku </p><p>Quetiapine Fair-Med i natychmiast skontaktować się z lekarzem prowadzącym lub zgłosić się po pomoc medyczną  </p><p>Zwiększenie masy ciała </p><p>U pacjentów stosujących lek Quetiapine Fair-Med obserwowano zwiększenie masy ciała. Pacjent i lekarz prowadzący powinni regularnie kontrolować masę ciała pacjenta. </p><p> </p><p>Dzieci i młodzież </p><p>Lek Quetiapine Fair-Med nie jest przeznaczony do stosowania u dzieci i młodzieży w wieku poniżej 18 lat. </p><p> </p><p>Lek Quetiapine Fair-Med a inne leki </p><p>4  </p><p>Należy powiedzieć lekarzowi o wszystkich lekach przyjmowanych przez pacjenta obecnie lub ostatnio, a także o lekach, które pacjent planuje przyjmować. </p><p> </p><p>Nie należy przyjmować leku Quetiapine Fair-Med, jeśli pacjent stosuje którykolwiek z następujących leków: </p><p> niektóre leki stosowane w leczeniu HIV  leki z grupy azoli (stosowane w zakażeniach grzybiczych)  erytromycynę lub klarytromycynę (stosowane w zakażeniach)  nefazodon (stosowany w leczeniu depresji). </p><p> </p><p>Należy powiedzieć lekarzowi, jeśli pacjent przyjmuje: </p><p> leki przeciwpadaczkowe (takie jak fenytoina lub karbamazepina)  leki przeciwnadciśnieniowe  barbiturany (leki stosowane w zaburzeniach snu)  tiorydazynę lub lit (inne leki przeciwpsychotyczne)  leki, które mają wpływ na rytm serca, na przykład leki zaburzające stężenie elektrolitów (zmniejszone stężenie potasu lub magnezu), takie jak leki moczopędne (odwadniające) lub wybrane antybiotyki (leki stosowane w zakażeniach)  leki, które mogą powodować zaparcie  tzw. leki przeciwcholinergiczne, które wpływają na funkcjonowanie komórek nerwowych, stosowane w leczeniu pewnych stanów chorobowych  </p><p>Przed zaprzestaniem stosowania któregokolwiek z leków należy najpierw skonsultować się z lekarzem. </p><p> </p><p>Lek Quetiapine Fair-Med z jedzeniem, piciem i alkoholem  lek Quetiapine Fair-Med może być przyjmowany jednocześnie z posiłkiem lub niezależnie od niego  należy uważać na ilość wypijanego alkoholu. Jednoczesne stosowanie leku </p><p>Quetiapine Fair-Med i alkoholu może wywołać senność  nie należy pić soku grejpfrutowego w czasie stosowania leku Quetiapine Fair-Med. </p><p>Może to wpływać na sposób działania leku  </p><p>Ciąża i karmienie piersią </p><p>Jeśli pacjentka jest w ciąży lub karmi piersią, przypuszcza że może być w ciąży lub gdy planuje mieć dziecko, powinna poradzić się lekarza przed zastosowaniem tego leku. </p><p>Leku Quetiapine Fair-Med nie należy stosować w czasie ciąży, chyba, że po konsultacji z lekarzem. Leku Quetiapine Fair- Med nie należy stosować w okresie karmienia piersią. </p><p> </p><p>Następujące objawy, które mogą wskazywać na zespół odstawienia, mogą wystąpić u noworodków, których matki przyjmowały kwetiapinę w ostatnich 3 miesiącach ciąży: drżenie, sztywność mięśni i (lub) osłabienie, senność, pobudzenie, problemy z oddychaniem i trudności przy karmieniu. Jeżeli u dziecka wystąpi którykolwiek z tych objawów, konieczny może być kontakt z lekarzem prowadzącym. </p><p> </p><p>Prowadzenie pojazdów i obsługa maszyn </p><p>Tabletki mogą powodować senność. Nie należy prowadzić pojazdów, używać narzędzi ani obsługiwać maszyn, dopóki pacjent nie upewni się, jak te tabletki na niego wpływają. </p><p> </p><p>Wpływ na badania moczu na zawartość leków </p><p>U pacjentów stosujących lek Quetiapine Fair-Med, badania moczu na obecność leków wykonywane niektórymi metodami mogą wykazywać obecność metadonu lub niektórych </p><p>5 leków stosowanych w depresji, nazywanych trójpierścieniowymi lekami przeciwdepresyjnymi (TCA), nawet jeśli pacjent nie stosuje tych leków. Zaleca się potwierdzenie wyników za pomocą badań wykonanych innymi metodami. </p><p> </p><p>Lek Quetiapine Fair-Med, 25 mg zawiera żółcień pomarańczową (E110), która może wywołać reakcje alergiczne. </p><p> </p><p>Lek Quetiapine Fair-Med zawiera laktozę jednowodna.  </p><p>Jeżeli stwierdzono wcześniej u pacjenta nietolerancję niektórych cukrów, pacjent powinien skontaktować się z lekarzem przed przyjęciem tego leku. </p><p>  </p><p>3. Jak przyjmować lek Quetiapine Fair-Med  </p><p>Lek Quetiapine Fair-Med należy zawsze przyjmować zgodnie z zaleceniami lekarza. W razie wątpliwości należy zwrócić się do lekarza lub farmaceuty. </p><p> </p><p>Dawkę początkową określi lekarz prowadzący. Dawka podtrzymująca (dawka dobowa) leku </p><p>Quetiapine Fair-Med będzie zależała od choroby i potrzeb pacjenta, ale zazwyczaj mieści się ona w zakresie od 150 mg do 800 mg. </p><p>  tabletki należy przyjmować raz na dobę na noc lub dwa razy na dobę, w zależności od choroby, na jaką cierpi pacjent. </p><p> tabletki należy połykać w całości, popijając wodą. </p><p> tabletki można przyjmować jednocześnie z posiłkiem lub niezależnie od niego. </p><p> nie należy pić soku grejpfrutowego podczas stosowania leku Quetiapine Fair-Med. </p><p>Może to wpływać na sposób działania leku. </p><p> nie należy przerywać stosowania leku, nawet jeśli pacjent poczuje się lepiej, chyba że tak zaleci lekarz. </p><p> </p><p>Pacjenci z zaburzeniami czynności wątroby </p><p>Lekarz może zalecić zmianę dawki leku u pacjenta z zaburzeniami czynności wątroby. </p><p> </p><p>Pacjenci w podeszłym wieku </p><p>Lekarz może zalecić zmianę dawki leku u pacjenta w podeszłym wieku. </p><p> </p><p>Stosowanie u dzieci i młodzież </p><p>Lek Quetiapine Fair-Med nie powinien być stosowany u dzieci i młodzieży w wieku poniżej </p><p>18 lat. </p><p> </p><p>Przyjęcie większej niż zalecana dawki leku Quetiapine Fair-Med </p><p>W razie przyjęcia większej dawki leku Quetiapine Fair-Med niż zalecana przez lekarza, pacjent może odczuwać senność, zawroty głowy i zaburzenia akcji serca. Należy niezwłocznie skontaktować się z lekarzem lub zgłosić się do najbliższego szpitala. Należy zabrać ze sobą opakowanie leku Quetiapine Fair-Med. </p><p> </p><p>Pominięcie zastosowania leku Quetiapine Fair-Med </p><p>Jeśli pacjent zapomniał zastosować dawkę leku, powinien zażyć ją jak najszybciej. Jeżeli zbliża się pora zastosowania kolejnej dawki, należy zażyć kolejną dawkę leku, pomijając ominiętą.. </p><p>Nie należy stosować dawki podwójnej w celu uzupełnienia ominiętej dawki. </p><p> </p><p>Przerwanie stosowania leku Quetiapine Fair-Med </p><p>W przypadku nagłego przerwania stosowania leku Quetiapine Fair-Med u pacjenta mogą </p><p>6 wystąpić trudności w zasypianiu (bezsenność), mdłości (nudności), bóle głowy, biegunka, wymioty, zawroty głowy lub drażliwość. Lekarz może zalecić stopniowe zmniejszanie dawki przed zakończeniem leczenia. </p><p> </p><p>W razie jakichkolwiek dalszych wątpliwości związanych ze stosowaniem tego leku, należy zwrócić się do lekarza lub farmaceuty. </p><p>  </p><p>4. Możliwe działania niepożądane  </p><p>Jak każdy lek, lek ten może powodować działania niepożądane, chociaż nie u każdego one wystąpią. </p><p> </p><p>Bardzo często występujące (mogą wystąpić u więcej niż u 1 na 10 osób): </p><p> zawroty głowy (mogące powodować upadki), ból głowy, suchość w jamie ustnej  senność (może powodować upadki; objaw ten często ustępuje podczas dalszego stosowania leku Quetiapine Fair-Med)  objawy odstawienia (objawy, które mogą wystąpić po przerwaniu stosowania leku </p><p>Quetiapine Fair-Med), w tym: trudności w zasypianiu (bezsenność), nudności, bóle głowy, biegunka, wymioty, zawroty głowy lub rozdrażnienie. Zaleca się stopniowe odstawianie leku przez przynajmniej od 1 do 2 tygodni  zwiększenie masy ciała  nieprawidłowe ruchy mięśni; może to być utrudnienie rozpoczęcia ruchu, drżenie, niepokój ruchowy lub sztywność mięśni bez bólu  zmiany zawartości we krwi niektórych substancji tłuszczowych (triglicerydów oraz cholesterolu całkowitego)  </p><p>Często występujące (mogą wystąpić u mniej niż 1 na 10 osób): </p><p> przyspieszone bicie serca  uczucie mocnego, szybkiego bicia serca lub braku niektórych uderzeń serca  zaparcia, niestrawność  osłabienie  obrzęki rąk lub nóg  niskie ciśnienie krwi podczas wstawania. Może to powodować zawroty głowy lub omdlenia (może prowadzić do upadków)  zwiększenie stężenia glukozy we krwi  niewyraźne widzenie  nietypowe sny i koszmary senne  wzmożone uczucie głodu  uczucie rozdrażnienia  zaburzenia mowy i sposobu wypowiadania się  myśli samobójcze i nasilenie depresji  duszność  wymioty (głównie u pacjentów w podeszłym wieku)  gorączka  zmiany stężeń hormonów tarczycy we krwi  zmniejszenie liczby niektórych rodzajów krwinek we krwi  zwiększenie stężeń enzymów wątrobowych mierzonych we krwi  zwiększenie stężenia hormonu – prolaktyny we krwi; zwiększone stężenie prolaktyny może prowadzić do:</p><p>- nabrzmienia piersi zarówno u mężczyzn, jak i kobiet, oraz nieoczekiwanego pojawienia się mleka </p><p>7 - braku lub nieregularnego miesiączkowania u kobiet  </p><p>Niezbyt często występujące (mogą wystąpiću mniej niż 1 na 100 osób): </p><p> napady drgawek  reakcje nadwrażliwości, które mogą obejmować krostki i bąble na skórze, obrzęki skóry i okolicy ust  nieprzyjemne odczucia w obrębie kończyn dolnych (tzw. zespół niespokojnych nóg)  utrudnione połykanie  niekontrolowane ruchy, głównie mięśni twarzy lub języka  zaburzenia seksualnej  cukrzyca  zmiana czynności elektrycznej serca widoczna w zapisie EKG (wydłużenie odstępu QT)  wolniejsza niż zwykle akcja serca, która może występować w czasie rozpoczynania leczenia i może być związana z obniżeniem ciśnienia tętniczego i omdleniami  utrudnienie w oddawaniu moczu  omdlenia (mogą prowadzić do upadków)  zatkany nos  zmniejszenie liczby krwinek czerwonych we krwi  zmniejszenie stężenia sodu we krwi  nasilenie istniejącej cukrzycy  </p><p>Rzadko występujące (mogą wystąpiću mniej niż 1 na 1000 osób): </p><p> połączenie wysokiej temperatury ciała (gorączki), obfitych potów, zesztywnienia mięśni, nasilonej senności lub omdlenia (zaburzenie zwane złośliwym zespołem neuroleptycznym)  zażółcenie skóry i gałek ocznych (żółtaczka)  zapalenie wątroby  długotrwała i bolesna erekcja (priapizm)  obrzęk piersi i niespodziewane wytwarzanie mleka (mlekotok)  zaburzenia miesiączkowania  zakrzepy żylne szczególnie w kończynach dolnych (objawy to: obrzęk, ból i zaczerwienienie nóg), które naczyniami krwionośnymi mogą dostać się do płuc powodując ból w klatce piersiowej i trudności w oddychaniu. Jeśli wystąpi którykolwiek z objawów, należy natychmiast poradzić się lekarza  chodzenie, mówienie, jedzenie i wykonywanie innych czynności podczas snu  obniżenie temperatury ciała (hipotermia)  zapalenie trzustki  stan (określany jako zespół metaboliczny) w którym występuje kombinacja trzech lub więcej spośród następujących cech: zwiększona ilość tłuszczu brzusznego, spadek stężenia „dobrego cholesterolu” (HDL-C), zwiększenie pewnego rodzaju substancji tłuszczowych we krwi (triglicerydów), wysokie ciśnienie tętnicze oraz zwiększenie stężenia cukru we krwi  łączne występowanie gorączki, objawów grypopodobnych, bólu gardła, lub obecność jakiegokolwiek innego zakażenia z bardzo małą liczbą krwinek białych we krwi (stan określany jako agranulocytoza)  niedrożność jelit  zwiększenie stężenia kinazy kreatynowej we krwi (substancja pochodząca z mięśni) </p><p>8  </p><p>Bardzo rzadko występujące (mogą wystąpić u mniej niż 1 na 10 000 osób): </p><p> ciężka wysypka, pęcherze, czerwone plamy na skórze  ciężka reakcja nadwrażliwości (zwana anafilaksją), która może powodować trudności w oddychaniu lub wstrząs  szybko pojawiający się obrzęk skóry, zazwyczaj dookoła oczu, ust lub gardła (obrzęk naczynioruchowy)  powstawanie pęcherzy na skórze, ustach, oczach i narządach płciowych (zespół </p><p>Stevensa-Johnsona)  nieprawidłowe wydzielanie hormonu regulującego objętość moczu  rozpad włókien mięśniowych i ból mięśni (rabdomioliza)  </p><p>Częstość nieznana (częstość nie może być określona na podstawie dostępnych danych  wysypka skórna z powstawaniem nieregularnych czerwonych plam (rumień wielopostaciowy)  ciężka, nagła reakcja alergiczna z objawami takimi jak gorączka i powstawanie pęcherzy na skórze i złuszczanie skóry (toksyczna martwica naskórka)  objawy odstawienia mogą wystąpić u noworodków matek, które przyjmowały lek </p><p>Quetiapine Fair-Med podczas ciąży  udar  zaburzenia mięśnia sercowego (kardiomiopatia)  zapalenie mięśnia sercowego  zapalenie naczyń krwionośnych (zapalenie naczyń), często z wysypką skórną z małymi czerwonymi lub fioletowymi guzkami  </p><p>Grupa leków, do której należy Quetiapine Fair-Med, może powodować zaburzenia rytmu serca, co może być stanem ciężkim, a nawet w pojedynczych przypadkach powodować zgon. </p><p> </p><p>Niektóre działania niepożądane można stwierdzić jedynie podczas badań laboratoryjnych krwi. </p><p>Zalicza się do nich zmiany stężeń niektórych tłuszczów (triglicerydów i cholesterolu całkowitego) lub cukru we krwi, zmiany stężeń hormonów tarczycy we krwi, zwiększenie stężeń enzymów wątrobowych we krwi, zmniejszenie liczby niektórych rodzajów krwinek, zmniejszenie liczby krwinek czerwonych we krwi, zwiększenie stężenia fosfokinazy kreatynowej we krwi (substancji występującej w mięśniach), zmniejszenie zawartości sodu we krwi oraz zwiększenie stężenia hormonu prolaktyny we krwi. Zwiększenie stężenia prolaktyny może w rzadkich przypadkach prowadzić do: </p><p>- obrzęku piersi i niespodziewanego wytwarzania mleka zarówno u kobiet jak i mężczyzn - zaniku lub nieregularnej miesiączki u kobiet  </p><p>Lekarz może od czasu do czasu zlecać wykonanie badań kontrolnych. </p><p> </p><p>Dodatkowe działania niepożądane u d zieci i młodzieży </p><p>Te same działania niepożądane, które są obserwowane u dorosłych mogą również wystąpić u dzieci i młodzieży. </p><p> </p><p>Następujące działania niepożądane występowały u dzieci i młodzieży częściej niż u pacjentów dorosłych, lub u pacjentów dorosłych nie występowały w ogóle: </p><p> </p><p>Bardzo często występujące (mogą wystąpiću więcej niż u 1 na 10 osób): </p><p> zwiększenie stężenia hormonu prolaktyny we krwi. Zwiększenie stężenia hormonu prolaktyny może w rzadkich przypadkach prowadzić do następujących zaburzeń: </p><p>- u chłopców i dziewcząt – do obrzęku piersi i niespodziewanego </p><p>9 wytwarzania mleka - u dziewcząt – do braku miesiączki lub nieregularnych miesiączek  wzmożony apetyt  wymioty  nietypowe skurcze mięśni, w tym: utrudnione rozpoczynanie ruchu, drżenie, niepokój ruchowy lub sztywność mięśni bez bólu  zwiększenie ciśnienia tętniczego krwi  </p><p>Często występujące (mogą wystąpić u mniej niż 1 na 10 osób): </p><p> uczucie osłabienia, omdlenia (może prowadzić do upadków)  zatkany nos  uczucie rozdrażnienia  </p><p>Zgłaszanie działań niepożądanych </p><p>Jeśli wystąpią jakiekolwiek objawy niepożądane, w tym wszelkie objawy niepożądane niewymienione w ulotce, należy powiedzieć o tym lekarzowi lub farmaceucie. Działania niepożądane można zgłaszać bezpośrednio do: </p><p>Departament Monitorowania Niepożądanych Działań Produktów Leczniczych Urzędu Rejestracji </p><p>Produktów Leczniczych, Wyrobów Medycznych i Produktów Biobójczych </p><p>Al. Jerozolimskie 181C </p><p>PL-02 222 Warszawa </p><p>Tel.: + 48 22 49 21 301 </p><p>Faks: + 48 22 49 21 309 </p> <p>150 mg: </p><p>Bladożółte, okrągłe, obustronnie wypukłe tabletki powlekane o średnicy około 10,45 mm. </p><p>200 mg: </p><p>Białe, okrągłe, obustronnie wypukłe tabletki powlekane z linią podziału po jednej stronie, o średnicy około 12,1 mm. </p><p>300 mg: </p><p>Białe, podłużne, obustronnie wypukłe tabletki powlekane z linią podziału po jednej stronie. Tabletka ma około 7 mm grubości, 19 mm długości i 9 mm szerokości. </p><p>12  </p><p>Data ostatniej aktualizacji ulotki:  </p>