<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html DIR="LTR">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link rel="icon" type="image/ico" href="/tools/dlpage/res/chrome/images/chrome-16.png"><title>Smluvní podmínky aplikace Google Chrome </title>
<style>
body { font-family:Arial; font-size:13px; }
h2 { font-size:1em; margin-top:0 }
</style>
<script type="text/javascript">
function carry_tracking(obj) {
    var s = '(\\?.*)';
    var regex = new RegExp(s);
    var results = regex.exec(window.location.href);
  if (results != null) {
    obj.href = obj.href + results[1];
  } else {
    s2 = 'intl/([^/]*)';
    regex2 = new RegExp(s2);
    results2 = regex2.exec(window.location.href);
    if (results2 != null) {
      obj.href = obj.href + '?hl=' + results2[1];
    }
  }
}
</script></head>

<body>
<h2>Smluvní podmínky aplikace Google Chrome </h2>
<p>Tyto Smluvní podmínky platí pro spustitelný kód aplikace Google Chrome. Zdrojový kód aplikace Google Chrome je k dispozici bezplatně na základě licenční smlouvy na software s otevřeným zdrojovým kódem na adrese http://code.google.com/chromium/terms.html.</p>
<p><strong>1. Vztah mezi vámi a společností Google</strong></p>
<p>1.1 Předmětem podmínek právně závazné smlouvy mezi vámi a společností Google je používání produktů, softwaru, služeb a webových stránek společnosti Google (v tomto dokumentu společně označovaných jako „Služby“, mimo služeb, které vám společnost Google poskytuje na základě samostatné písemné smlouvy). „Google” znamená společnost Google Inc., s hlavním obchodním sídlem na adrese 1600 Amphitheatre Parkway, Mountain View, CA 94043, USA. Tento dokument vysvětluje, jak je smlouva sestavena, a stanovuje některé její podmínky.</p>
<p>1.2 Není-li se společností Google písemně dohodnuto jinak, bude vaše smlouva se společností Google vždy obsahovat alespoň smluvní podmínky stanovené v tomto dokumentu. Tyto podmínky jsou dále v textu označovány jako „Univerzální smluvní podmínky“. Licence na software s otevřeným zdrojovým kódem, které se vztahují na zdrojový kód aplikace Google Chrome, jsou samostatnými smlouvami. V omezeném rozsahu, kdy licence na software s otevřeným zdrojovým kódem výslovně nahrazují tyto Univerzální smluvní podmínky, určují váš vztah se společností Google z hlediska použití aplikace Google Chrome nebo určitých zahrnutých komponent aplikace Google Chrome licence na software s otevřeným zdrojovým kódem.</p>
<p>1.3 Součástí vaší smlouvy se společností Google budou kromě Univerzálních smluvních podmínek také Dodatečné smluvní podmínky aplikace Google Chrome a veškeré Právní doložky, které se týkají Služeb. Ty jsou společně dále v textu označovány jako „Dodatečné smluvní podmínky“. Pokud se ke Službě vztahují Dodatečné smluvní podmínky, budete si je moci přečíst buď v rámci příslušné Služby, nebo prostřednictvím jejího používání.</p>
<p>1.4 Univerzální smluvní podmínky, společně s Dodatečnými smluvními podmínkami, tvoří právně závaznou smlouvu mezi vámi a společností Google v souvislosti s vaším používáním Služeb. Je důležité, abyste si je pečlivě přečetli. Společně je tato právně závazná smlouva dále v textu označována jako „Smluvní podmínky“.</p>
<p>1.5 Existuje-li jakýkoli rozpor mezi tím, co říkají Dodatečné smluvní podmínky a tím, co říkají Univerzální smluvní podmínky, mají ve vztahu k dané Službě přednost Dodatečné smluvní podmínky.</p>
<p><strong>2. Přijetí Smluvních podmínek</strong></p>
<p>2.1 Abyste mohli Služby používat, musíte nejprve souhlasit se Smluvními podmínkami. Nepřijmete-li Smluvní podmínky, nesmíte Služby používat.</p>
<p>2.2 Smluvní podmínky můžete přijmout:</p>
<p>(A) kliknutím pro potvrzení přijetí nebo souhlasu se Smluvními podmínkami, pokud tuto možnost Google v uživatelském rozhraní určité Služby poskytuje; nebo</p>
<p>(B) vlastním používáním Služeb. V takovém případě jste srozuměni a souhlasíte s tím, že společnost Google bude od tohoto okamžiku považovat vaše používání Služeb za přijetí Smluvních podmínek.</p>
<p><strong>3. Jazyk Smluvních podmínek</strong></p>
<p>3.1 Pokud vám společnost Google poskytla překlad anglické jazykové verze Smluvních podmínek, pak souhlasíte s tím, že překlad je poskytnut pouze pro vaši potřebu, a že váš vztah se společností Google se bude řídit zněním Smluvních podmínek v angličtině.</p>
<p>3.2 Existuje-li jakýkoli rozpor mezi tím, co říká anglická jazyková verze Smluvních podmínek, a tím, co je uvedeno v překladu, má přednost znění Smluvních podmínek v angličtině.</p>
<p><strong>4. Poskytování Služeb ze strany společnosti Google</strong></p>
<p>4.1 Společnost Google má dceřiné společnosti a přidružené subjekty na celém světě (dále jen „Dceřiné společnosti a přidružené subjekty“). Někdy vám tyto společnosti budou poskytovat Služby jménem samotné společnosti Google. Berete na vědomí a souhlasíte s tím, že dceřiné společnosti a přidružené subjekty budou mít právo poskytovat vám Služby.</p>
<p>4.2 Společnost Google neustále zavádí inovace, aby svým uživatelům poskytovala co nejlepší služby. Berete na vědomí a souhlasíte s tím, že forma a povaha Služeb, které společnost Google poskytuje, se může bez předchozího oznámení čas od času změnit.</p>
<p>4.3 Berete na vědomí a souhlasíte s tím, že v rámci těchto průběžných inovací může společnost Google zastavit (trvale nebo dočasně) poskytování určitých Služeb (nebo jakýchkoli funkcí těchto Služeb) vám nebo uživatelům obecně, a to dle vlastního zvážení a bez předchozího oznámení. Používání Služeb můžete kdykoli ukončit. Když Služby přestanete používat, nemusíte o tom společnost Google nijak informovat.</p>
<p>4.4 Berete na vědomí a souhlasíte s tím, že pokud vám společnost Google zablokuje přístup k vašemu účtu, může vám být zabráněno v přístupu ke Službám, informacím o vašem účtu nebo souborům a dalšímu obsahu, který je ve vašem účtu obsažen.</p>
<p><strong>5. Používání Služeb z vaší strany</strong></p>
<p>5.1 Zavazujete se, že budete využívat Služby pouze pro účely povolené (a) Smluvními podmínkami a (b) příslušnými zákony, nařízeními nebo obecně přijímanými pravidly či pokyny v relevantních jurisdikcích (včetně všech zákonů týkajících se exportu dat nebo softwaru do a ze Spojených států nebo jiných relevantních zemí).</p>
<p>5.2 Souhlasíte s tím, že se nebudete účastnit žádné aktivity, která by ovlivňovala nebo narušovala Služby (nebo servery a sítě spojené se Službami).</p>
<p>5.3 Souhlasíte s tím, že Služby z žádného důvodu nebudete reprodukovat, duplikovat, kopírovat ani prodávat, nebudete-li k tomu výslovně oprávněni na základě zvláštní smlouvy se společností Google.</p>
<p>5.4 Souhlasíte s tím, že jste plně odpovědní (a že společnost Google nemá žádnou odpovědnost vůči vám ani žádné třetí straně) za jakékoli porušení vašich povinností vyplývajících ze Smluvních podmínek a za následky takového porušení (včetně jakékoli ztráty nebo škody, kterou společnost Google může utrpět).</p>
<p><strong>6. Ochrana soukromí a osobní údaje</strong></p>
<p>6.1 Informace o způsobu, jakým společnost Google chrání vaše data, naleznete v zásadách ochrany osobních údajů na adresách http://www.google.com/privacy.html a
http://www.google.com/chrome/intl/cs/privacy.html. Tyto zásady vysvětlují, jak společnost Google zachází s vašimi osobními údaji a jak chrání vaše soukromí, když používáte Služby.</p>
<p>6.2 Souhlasíte s používáním vašich dat v souladu se zásadami ochrany osobních údajů společnosti Google.</p>
<p><strong>7. Obsah ve Službách</strong></p>
<p>7.1 Berete na vědomí, že za všechny informace (jako jsou datové soubory, písemný text, počítačový software, hudba, zvukové soubory nebo jiné zvuky, fotografie, videa nebo jiné obrázky), k nimž můžete mít přístup v rámci Služeb či jejich používání, je plně odpovědná osoba, od níž tento obsah pochází. Všechny tyto informace jsou dále v textu označovány jako „Obsah“.</p>
<p>7.2 Mějte na paměti, že Obsah, který je vám prezentován jako součást Služeb, včetně, mimo jiné, reklam a sponzorovaného Obsahu v rámci Služeb, může být chráněn právy k duševnímu vlastnictví, která vlastní sponzoři nebo inzerenti, kteří tento Obsah poskytli společnosti Google (nebo jiné osoby nebo společnosti jednající jejich jménem). Tento Obsah nesmíte upravovat, pronajímat, poskytovat na leasing, půjčovat, prodávat, šířit ani z něj vytvářet odvozená díla (ať už z celku nebo jeho části), nebude-li vám to v samostatné smlouvě výslovně povoleno společností Google nebo vlastníky daného Obsahu.</p>
<p>7.3 Společnost Google si vyhrazuje právo (není však povinna) předběžně třídit, kontrolovat, označovat, filtrovat, upravovat, zamítat nebo přesouvat libovolný nebo veškerý Obsah z jakékoli Služby. U některých služeb poskytuje společnost Google nástroje pro filtrování pornografického obsahu. K těmto nástrojům patří nastavení předvoleb Bezpečného vyhledávání (viz http://www.google.cz/help/customize.html#safe). Kromě toho existují komerčně dostupné služby a software umožňující omezení přístupu k materiálu, který můžete považovat za nevhodný.</p>
<p>7.4 Berete na vědomí, že při používání Služeb můžete být vystaveni Obsahu, který pro vás může být urážlivý, nemravný nebo nežádoucí, a že v tomto ohledu Služby používáte na vlastní nebezpečí.</p>
<p>7.5 Souhlasíte s tím, že jste plně odpovědní (a že společnost Google nemá žádnou odpovědnost vůči vám ani žádné třetí straně) za jakýkoli Obsah, který vytvoříte, přenesete nebo zobrazíte při používání Služeb a za následky této své činnosti (včetně jakékoli ztráty nebo škody, kterou tím může utrpět společnost Google).</p>
<p><strong>8. Vlastnická práva</strong></p>
<p>8.1 Berete na vědomí a souhlasíte s tím, že společnost Google (nebo poskytovatelé licencí společnosti Google) vlastní veškerá zákonná práva a nároky na Služby a podíly v nich, včetně jakýchkoli práv k duševnímu vlastnictví, která jsou ve Službách obsažena (ať už jsou tato práva registrována či nikoliv, a bez ohledu na to, v které části světa tato práva existují).</p>
<p>8.2 Pokud jste se se společností Google nedohodli písemně jinak, nedává vám žádné ustanovení Smluvních podmínek právo používat žádné obchodní názvy, ochranné známky, značky služeb, loga, názvy domén ani jiné charakteristické prvky značky Google.</p>
<p>8.3 Pokud vám bylo samostatnou písemnou smlouvou se společností Google výslovně uděleno právo používat některé z těchto charakteristických prvků značky, pak souhlasíte s tím, že tyto charakteristické prvky budete používat v souladu s onou smlouvou, veškerými platnými ustanoveními Smluvních podmínek a pokyny pro používání charakteristických prvků značky Google, které mohou být čas od času aktualizovány. Tyto pokyny naleznete na adrese http://www.google.cz/permissions/guidelines.html (nebo na jiné takové adrese URL, kterou může společnost Google čas od času poskytnout).</p>
<p>8.4·Společnost Google bere na vědomí a souhlasí s tím, že na základě těchto Smluvních podmínek od vás (nebo vašich poskytovatelů licence) nezískává žádná práva, nároky ani podíly na jakýkoliv Obsah, který odešlete, zveřejníte, přenesete nebo zobrazíte v rámci Služeb nebo jejich prostřednictvím, včetně jakýchkoli práv k duševnímu vlastnictví, která se k tomuto Obsahu váží (ať už jsou tato práva registrována či nikoliv a bez ohledu na to, v které části světa tato práva existují). Pokud jste se nedohodli se společností Google písemně jinak, souhlasíte s tím, že jste odpovědní za ochranu a vymáhání těchto práv, a že společnost Google není povinna takto činit vaším jménem.</p>
<p>8.5 Souhlasíte s tím, že nebudete odstraňovat, skrývat či pozměňovat informace o vlastnických právech (včetně informací o autorských právech a ochranných známkách), které mohou být připojeny ke Službám nebo v nich mohou být obsaženy.</p>
<p>8.6 Pokud vám to nebylo společností Google výslovně písemně povoleno, souhlasíte s tím, že při používání Služeb nebudete používat žádnou ochrannou známku, servisní značku, obchodní název ani logo jakékoli společnosti nebo organizace způsobem, který by mohl nebo má působit matoucím dojmem ohledně vlastníka nebo oprávněného uživatele těchto známek, názvů nebo log.</p>
<p><strong>9. Licence poskytnutá společností Google</strong></p>
<p>9.1 Společnost Google vám uděluje osobní, celosvětově platnou, bezplatnou, nepřevoditelnou a nevýhradní licenci k používání softwaru (dále v textu označován jako „Software“), který společnost Google poskytuje jako součást Služeb poskytovaných vám společností Google. Výhradním účelem této licence je umožnit vám používat Služby a využívat jejich přínosy způsobem povoleným ve Smluvních podmínkách.</p>
<p>9.2 S ohledem na ustanovení odstavce 1.2 nesmíte (a nesmíte ani dovolit komukoli jinému) kopírovat, upravovat, vytvářet odvozená díla, provádět zpětnou analýzu, dekompilovat ani se jinak pokoušet extrahovat zdrojový kód ze Softwaru nebo jeho části, není-li to výslovně povoleno nebo vyžadováno zákonem, nebo nebylo-li vám to písemně výslovně povoleno společností Google.</p>
<p>9.3 S ohledem na ustanovení odstavce 1.2 nesmíte převádět svá práva (ani poskytovat další licence) na použití Softwaru, ani zatěžovat Software zástavním právem nebo jiným způsobem převádět jakoukoli část svých práv na používání Softwaru, pokud vám to společnost Google výslovně písemně nepovolila.</p>
<p><strong>10. Vámi poskytnutá licence k Obsahu</strong></p>
<p>10.1 K Obsahu, který odešlete, zveřejníte nebo zobrazíte v rámci Služeb nebo jejich prostřednictvím, si ponecháváte autorská práva a jakákoli jiná práva, která k tomuto Obsahu vlastníte.</p>
<p><strong>11. Aktualizace softwaru</strong></p>
<p>11.1 Software, který používáte, může čas od času od společnosti Google automaticky stahovat a instalovat aktualizace. Tyto aktualizace jsou určeny ke zlepšení, rozšíření a dalšímu rozvoji Služeb a mohou mít podobu oprav chyb, rozšířených funkcí, nových softwarových modulů a zcela nových verzí. Souhlasíte s tím, že jako součást svého používání Služeb budete tyto aktualizace přijímat (a dovolíte společnosti Google vám je dodat).</p>
<p><strong>12. Ukončení vašeho vztahu se společností Google</strong></p>
<p>12.1 Platnost těchto Smluvních podmínek potrvá až do ukončení z vaší strany nebo ze strany společnosti Google, jak je popsáno níže.</p>
<p>12.2 Společnost Google smí kdykoli ukončit svůj právní vztah s vámi, pokud:</p>
<p>(A) jste porušili kterékoli ustanovení Smluvních podmínek (nebo jste jednali způsobem, který jasně vykazoval úmysl tak učinit, nebo nejste schopni dodržet ustanovení Smluvních podmínek); nebo</p>
<p>(B) společnost Google byla ze zákona povinna tak učinit (například, pokud ustanovení Služeb je nebo se pro vás stane nezákonným); nebo</p>
<p>(C) partner, se kterým vám společnost Google nabízela Služby, ukončil svůj vztah se společností Google nebo vám Služby přestal nabízet; nebo</p>
<p>(D) společnost Google přestane poskytovat Služby uživatelům v zemi, ve které sídlíte nebo ze které Službu používáte; nebo</p>
<p>(E) poskytování Služeb společností Google vám již není, z pohledu společnosti Google, obchodně realizovatelné.</p>
<p>12.3 Žádné ustanovení v tomto odstavci neovlivňuje práva společnosti Google, pokud jde o poskytování Služeb, uvedená v odstavci 4 Smluvních podmínek.</p>
<p>12.4 Ukončením těchto Smluvních podmínek nebudou ovlivněna žádná zákonná práva, povinnosti ani závazky, které jste vy a společnost Google měli (nebo které jste získali v době, kdy byly Smluvní podmínky v platnosti), nebo které výslovně mají zůstat v platnosti, a na tato práva, povinnosti a závazky se bude nadále a bez časového omezení vztahovat ustanovení odstavce 19.7.</p>
<p><strong>13. VYLOUČENÍ ZÁRUK</strong></p>
<p>13.1 ŽÁDNÉ USTANOVENÍ TĚCHTO SMLUVNÍCH PODMÍNEK VČETNĚ ODDÍLŮ 13 A 14 NEVYLUČUJE ANI NEOMEZUJE ODPOVĚDNOST SPOLEČNOSTI GOOGLE ZA ŠKODY, KTERÉ NELZE PODLE PŘÍSLUŠNÉHO ZÁKONA VYLOUČIT NEBO OMEZIT. NĚKTERÉ PRÁVNÍ ŘÁDY NEDOVOLUJÍ VYLOUČENÍ URČITÝCH ZÁRUK A PODMÍNEK NEBO OMEZENÍ ČI VYLOUČENÍ ODPOVĚDNOSTI ZA ŠKODY ZPŮSOBENÉ NEDBALOSTÍ, PORUŠENÍM SMLOUVY NEBO PORUŠENÍM PODMÍNEK VYPLÝVAJÍCÍCH ZE ZÁKONA NEBO ODPOVĚDNOSTI ZA VEDLEJŠÍ ČI NÁSLEDNÉ ŠKODY. Z TOHOTO DŮVODU SE VÁS TÝKAJÍ POUZE TA OMEZENÍ, KTERÁ JSOU V SOULADU S VAŠÍM PRÁVNÍM ŘÁDEM. NAŠE ODPOVĚDNOST JE OMEZENA V MAXIMÁLNÍ MOŽNÉ MÍŘE PŘÍPUSTNÉ PODLE ZÁKONA.</p>
<p>13.2 VÝSLOVNĚ BERETE NA VĚDOMÍ A SOUHLASÍTE S TÍM, ŽE POUŽITÍ SLUŽEB JE NA VAŠE VLASTNÍ NEBEZPEČÍ A ŽE SLUŽBY JSOU POSKYTOVÁNY „TAK, JAK JSOU“ A „JAK JSOU K DISPOZICI“.</p>
<p>13.3 SPOLEČNOST GOOGLE, JEJÍ DCEŘINÉ SPOLEČNOSTI A PŘIDRUŽENÉ SUBJEKTY A JEJÍ POSKYTOVATELÉ LICENCE ZEJMÉNA NEPROHLAŠUJÍ A NEZARUČUJÍ, ŽE:</p>
<p>(A) POUŽÍVÁNÍ SLUŽEB BUDE SPLŇOVAT VAŠE POŽADAVKY,</p>
<p>(B) POUŽÍVÁNÍ SLUŽEB BUDE NEPŘERUŠENÉ, VČASNÉ A BEZPEČNÉ NEBO BEZCHYBNÉ,</p>
<p>(C) VŠECHNY INFORMACE, KTERÉ ZÍSKÁTE V DŮSLEDKU POUŽÍVÁNÍ SLUŽEB, BUDOU PŘESNÉ A SPOLEHLIVÉ, A</p>
<p>(D) ŽE CHYBY FUNGOVÁNÍ NEBO FUNKČNOSTI JAKÉHOKOLI SOFTWARU, KTERÝ JE VÁM POSKYTOVÁN V RÁMCI SLUŽEB, BUDOU OPRAVENY.</p>
<p>13.4 VEŠKERÉ MATERIÁLY STAŽENÉ NEBO JINAK ZÍSKANÉ V SOUVISLOSTI S VYUŽÍVÁNÍM SLUŽEB BUDETE POUŽÍVAT NA ZÁKLADĚ VLASTNÍHO ROZHODNUTÍ A NA VLASTNÍ NEBEZPEČÍ A NESETE VÝHRADNÍ ODPOVĚDNOST ZA POŠKOZENÍ SVÉHO POČÍTAČOVÉHO SYSTÉMU ČI JINÉHO ZAŘÍZENÍ NEBO ZA ZTRÁTU DAT, K NIMŽ MŮŽE DOJÍT V DŮSLEDKU STAŽENÍ TAKOVÝCHTO MATERIÁLŮ.</p>
<p>13.5 JAKÁKOLI ÚSTNÍ NEBO PÍSEMNÁ DOPORUČENÍ ČI INFORMACE, KTERÉ ZÍSKÁTE OD SPOLEČNOSTI GOOGLE NEBO PROSTŘEDNICTVÍM SLUŽEB, NEZAKLÁDAJÍ ŽÁDNOU ZÁRUKU, KTERÁ NENÍ VÝSLOVNĚ UVEDENA V PODMÍNKÁCH.</p>
<p>13.6 SPOLEČNOST GOOGLE DÁLE VÝSLOVNĚ ODMÍTÁ VŠECHNY VÝSLOVNÉ I PŘEDPOKLÁDANÉ ZÁRUKY A PODMÍNKY JAKÉHOKOLI DRUHU, MIMO JINÉ VČETNĚ ZÁRUK VYPLÝVAJÍCÍCH ZE ZÁKONA NEBO JINÝCH SMLUV A PODMÍNEK OBCHODOVATELNOSTI, VHODNOSTI KE KONKRÉTNÍMU ÚČELU A NEPORUŠENÍ PRÁV.</p>
<p><strong>14. OMEZENÍ ODPOVĚDNOSTI</strong></p>
<p>14.1 S PŘIHLÉDNUTÍM K OBECNÉMU USTANOVENÍ UVEDENÉMU V ODSTAVCI 13.1 VÝŠE, SPOLEČNOST GOOGLE, JEJÍ DCEŘINÉ SPOLEČNOSTI A PŘIDRUŽENÉ SUBJEKTY A JEJÍ POSKYTOVATELÉ LICENCE NEBUDOU VŮČI VÁM ODPOVĚDNÍ ZA:</p>
<p>(A) JAKÉKOLI PŘÍMÉ, NEPŘÍMÉ, VEDLEJŠÍ, ZVLÁŠTNÍ NÁSLEDNÉ NEBO EXEMPLÁRNÍ ŠKODY, KTERÉ VÁM MOHOU VZNIKNOUT, AŤ UŽ BYLY ZAPŘÍČINĚNY JAKKOLI A NA ZÁKLADĚ JAKÉKOLI TEORIE ODPOVĚDNOSTI. TY ZAHRNUJÍ, ALE NEJSOU OMEZENY NA JAKÝKOLI (PŘÍMO ČI NEPŘÍMO) UŠLÝ ZISK, JAKOUKOLIV ZTRÁTU DOBRÉ POVĚSTI NEBO DOBRÉHO OBCHODNÍHO JMÉNA, JAKOUKOLIV ZTRÁTU DAT, NÁKLADY NA OBSTARÁNÍ NÁHRADNÍHO ZBOŽÍ ČI SLUŽEB A JINÉ NEHMOTNÉ ZTRÁTY;</p>
<p>(B) JAKÉKOLI ZTRÁTY NEBO ŠKODY, KTERÉ VÁM MOHOU VZNIKNOUT, MIMO JINÉ VČETNĚ ZTRÁT ČI ŠKOD, KTERÉ JSOU VÝSLEDKEM:</p>
<p>(I) JAKÉHOKOLI SPOLÉHÁNÍ SE NA ÚPLNOST, PŘESNOST NEBO EXISTENCI JAKÉKOLI INZERCE NEBO VÝSLEDKEM JAKÉHOKOLI VZTAHU NEBO TRANSAKCE MEZI VÁMI A INZERENTEM NEBO SPONZOREM, JEHOŽ INZERCE SE ZOBRAZUJE VE SLUŽBÁCH;</p>
<p>(II) JAKÝCHKOLI ZMĚN, KTERÉ MŮŽE SPOLEČNOST GOOGLE VE SLUŽBÁCH UČINIT, NEBO JAKÉHOKOLI TRVALÉHO ČI DOČASNÉHO ZASTAVENÍ POSKYTOVÁNÍ SLUŽEB (NEBO KTERÝCHKOLI FUNKCÍ V RÁMCI SLUŽEB);</p>
<p>(III) SMAZÁNÍ, POŠKOZENÍ ČI NEULOŽENÍ LIBOVOLNÉHO OBSAHU A JINÝCH SDĚLENÍ, KTERÁ JSOU UCHOVÁVÁNA NEBO PŘENÁŠENA PROSTŘEDNICTVÍM SLUŽEB NEBO PŘI JEJICH VYUŽÍVÁNÍ;</p>
<p>(IV) VAŠEHO NEPOSKYTNUTÍ PŘESNÝCH ÚDAJŮ O ÚČTU SPOLEČNOSTI GOOGLE;</p>
<p>(V) VAŠEHO OPOMENUTÍ UCHOVAT SVÉ HESLO NEBO PODROBNOSTI O ÚČTU V BEZPEČÍ A DŮVĚRNOSTI.</p>
<p>14.2 OMEZENÍ ODPOVĚDNOSTI SPOLEČNOSTI GOOGLE VŮČI VÁM, POPSANÉ VÝŠE V ODSTAVCI 14.1 PLATÍ, AŤ UŽ BYLA SPOLEČNOST GOOGLE UPOZORNĚNA NA MOŽNOST VZNIKU TAKOVÝCH ŠKOD NEBO SI JÍ MOHLA BÝT VĚDOMA, ČI NIKOLIV.</p>
<p><strong>15. Zásady týkající se autorských práv a ochranných známek</strong></p>
<p>15.1 Jednou ze zásad společnosti Google je reagovat na oznámení o údajném porušení autorských práv podle příslušného mezinárodního práva o duševním vlastnictví (včetně zákona Digital Millennium Copyright Act ve Spojených státech) a ukončovat účty uživatelů, kteří tyto zákony opakovaně porušují. Podrobnosti o zásadách společnosti Google naleznete na adrese http://www.google.cz/dmca.html.</p>
<p>15.2 V souvislosti se svou reklamní činností poskytuje společnost Google postup pro řešení stížností týkajících se ochranných známek. Podrobnosti o tomto postupu naleznete na adrese http://www.google.cz/tm_complaint.html.</p>
<p><strong>16. Reklamy</strong></p>
<p>16.1 Některé Služby jsou podporovány prostřednictvím výnosů z reklamy, a proto mohou zobrazovat reklamy a nabídky. Tyto reklamy mohou být cíleny na informační obsah uložený v rámci Služeb, na dotazy provedené prostřednictvím Služeb nebo na jiné informace.</p>
<p>16.2 Povaha, forma a rozsah reklam od společnosti Google u Služeb se mohou změnit bez předchozího oznámení.</p>
<p>16.3 S ohledem na udělení přístupu ke Službám a vaše používání Služeb ze strany společnosti Google souhlasíte s tím, že společnost Google může tyto reklamy do Služeb umístit.</p>
<p><strong>17. Další obsah</strong></p>
<p>17.1 Služby mohou obsahovat hypertextové odkazy na jiné webové stránky nebo obsah či zdroje. Společnost Google nemusí mít kontrolu nad jakýmikoli webovými stránkami nebo zdroji, které jsou poskytovány společnostmi nebo osobami jinými než je společnost Google.</p>
<p>17.2 Berete na vědomí a souhlasíte s tím, že společnost Google neodpovídá za dostupnost jakýchkoli těchto externích stránek a zdrojů, a že neschvaluje ani neodpovídá za žádnou reklamu, produkty či jiný materiál dostupný prostřednictvím těchto webových stránek a zdrojů.</p>
<p>17.3 Berete na vědomí a souhlasíte s tím, že společnost Google neodpovídá za žádné ztráty nebo škody, které můžete případně utrpět v důsledku dostupnosti těchto externích stránek nebo zdrojů, nebo v důsledku toho, že jste se spoléhali na úplnost, přesnost nebo existenci jakékoli reklamy, produktů nebo jiných materiálů umístěných na těchto webových stránkách nebo zdrojích nebo dostupných jejich prostřednictvím.</p>
<p><strong>18. Změny Smluvních podmínek</strong></p>
<p>18.1 Společnost Google může Univerzální smluvní podmínky nebo Dodatečné smluvní podmínky čas od času změnit. Po provedení těchto změn společnost Google zveřejní nové znění Univerzálních smluvních podmínek na adrese http://www.google.com/chrome/intl/cs/eula_text.html; případné nové Dodatečné smluvní podmínky vám budou zpřístupněny v rámci dotčených Služeb nebo jejich prostřednictvím.</p>
<p>18.2 Berete na vědomí a souhlasíte s tím, že pokud budete používat Služby po datu, k němuž se Univerzální smluvní podmínky nebo Dodatečné smluvní podmínky změnily, bude to společnost Google považovat za vaše přijetí aktualizovaných Univerzálních smluvních podmínek nebo Dodatečných smluvních podmínek.</p>
<p><strong>19. Obecné právní podmínky</strong></p>
<p>19.1 Při používání Služeb můžete (v souvislosti s používáním Služeb nebo v jeho důsledku) občas použít službu, stáhnout software nebo zakoupit zboží, které poskytuje jiná osoba nebo společnost. Vaše používání těchto jiných služeb, softwaru nebo zboží může být předmětem samostatných smluvních podmínek mezi vámi a příslušnou společností nebo osobou. V takovém případě Smluvní podmínky neovlivňují váš právní vztah s těmito jinými společnostmi nebo osobami.</p>
<p>19.2 Smluvní podmínky představují úplné právní ujednání mezi vámi a společností Google a řídí vaše používání Služeb (avšak mimo jakýchkoli služeb, které vám společnost Google může poskytovat na základě samostatné písemné smlouvy) a zcela nahrazují jakákoli předchozí ujednání mezi vámi a společností Google týkající se Služeb.</p>
<p>19.3 Souhlasíte s tím, že společnost Google je oprávněna poskytovat vám oznámení, včetně oznámení týkajících se změn Smluvních podmínek e-mailem, běžnou poštou nebo zveřejněním na stránkách Služeb.</p>
<p>19.4 Souhlasíte s tím, že pokud společnost Google neuplatní nebo nebude vymáhat nějaké právo nebo nápravné opatření obsažené ve Smluvních podmínkách (nebo které může společnost Google využívat na základě platného práva), nelze to považovat za formální vzdání se těchto práv ze strany společnosti Google, a tato práva nebo nápravná opatření budou společnosti Google nadále k dispozici.</p>
<p>19.5 Pokud jakýkoli soud s rozhodovací pravomocí v dané záležitosti rozhodne, že jakékoli ustanovení těchto Smluvních podmínek je neplatné, bude toto ustanovení ze Smluvních podmínek vyňato, aniž by tím byla ovlivněna zbývající ustanovení Smluvních podmínek. Zbývající ustanovení Smluvních podmínek zůstávají nadále platná a vymahatelná.</p>
<p>19.6 Berete na vědomí a souhlasíte s tím, že každý člen skupiny společností, jejíž mateřskou společností je společnost Google, bude oprávněnou třetí stranou Smluvních podmínek, a že tyto další společnosti budou oprávněny přímo vymáhat a spoléhat se na jakákoliv ustanovení Smluvních podmínek, z kterých mohou mít prospěch (nebo která jim poskytují práva). Kromě výše uvedeného nesmí být oprávněnou třetí stranou těchto Smluvních podmínek žádná jiná osoba ani společnost.</p>
<p>19.7 Smluvní podmínky a vztah mezi vámi a společností Google podle Smluvních podmínek se řídí zákony státu Kalifornie bez ohledu na jejich ustanovení o kolizi právních norem. Vy i společnost Google souhlasíte s tím, že se pro řešení všech právních záležitostí vyplývajících z těchto Smluvních podmínek podrobíte výhradní jurisdikci soudů v okresu Santa Clara ve státě Kalifornie. Bez ohledu na výše uvedené souhlasíte s tím, že společnost Google bude i nadále oprávněna požádat o příkaz k nápravě (nebo ekvivalentní typ bezodkladného opravného prostředku) v jakékoli jurisdikci.</p>
<p><strong>20. Dodatečné smluvní podmínky pro rozšíření pro Google Chrome</strong></p>
<p>20.1 Podmínky uvedené v této sekci platí, pokud do své kopie aplikace Google Chrome nainstalujete rozšíření. Rozšíření jsou malé softwarové programy vyvinuté společností Google nebo třetími stranami, které mohou změnit nebo vylepšit funkčnost aplikace Google Chrome. Rozšíření mohou mít větší přístupová práva k vašemu prohlížeči nebo počítači než běžné webové stránky, včetně možnosti číst a upravovat vaše soukromá data.</p>
<p>20.2 Čas od času může Google Chrome na vzdálených serverech (společnosti Google nebo třetích stran) zkontrolovat dostupnost aktualizací rozšíření, včetně (mimo jiné) oprav chyb a vylepšení funkčnosti. Souhlasíte s tím, že tyto aktualizace budou automaticky vyžádány, staženy a nainstalovány, aniž byste o tom byli dále informováni.</p>
<p>20.3 Čas od času může společnost Google odhalit rozšíření, které porušuje podmínky pro vývojáře společnosti Google nebo jiné právní dohody, zákony, předpisy nebo zásady. Google Chrome bude pravidelně stahovat seznam takových rozšíření ze serverů společnosti Google. Souhlasíte s tím, že společnost Google může jakékoliv takové rozšíření na základě vlastního zvážení v počítačích uživatelů vzdáleně deaktivovat nebo odebrat. </p>
<p><strong>21. Dodatečné podmínky pro použití ve firmách</strong></p>
<p>21.1 Pokud jste právnická osoba, potom jednotlivec, který tyto Smluvní podmínky přijímá vaším jménem (aby nevznikly pochybnosti, v případě právnických osob se v těchto Smluvních podmínkách slovem „vy“ myslí právnická osoba), prohlašuje a zaručuje, že je oprávněn jednat vaším jménem, že máte potřebná oprávnění k podnikání v zemích, ve kterých působíte, a že vaši zaměstnanci, pracovníci, zástupci a jiní činitelé, kteří přistupují ke Službě, mají náležité oprávnění přistupovat do aplikace Google Chrome a právně vás zavazovat k těmto Smluvním podmínkám.</p>
<p>21.2 V souladu s těmito Smluvními podmínkami a jako dodatek k udělení licence v odstavci 9 vám společnost Google uděluje neexkluzivní, nepřenosnou licenci k reprodukci, distribuci, instalaci a použití aplikace Google Chrome pouze v počítačích určených k použití vašimi zaměstnanci, pracovníky, zástupci a činiteli ve spojení s vaší právnickou osobou pod podmínkou, že použití bude v souladu s těmito Smluvními podmínkami.</p>
<p>12. srpna 2010</p>
<br>
<hr>
<br>
<h2>Dodatečné smluvní podmínky aplikace Google Chrome</h2>
<p><strong>MPEGLA</strong></p>
<p>TENTO PRODUKT JE LICENCOVÁN V RÁMCI LICENCE NA PORTFOLIO PATENTŮ AVC PRO OSOBNÍ A NEKOMERČNÍ POUŽITÍ UŽIVATELEM K TĚMTO ÚČELŮM: (i) KE KÓDOVÁNÍ VIDEA V SOULADU SE STANDARDEM AVC (DÁLE JEN „VIDEO AVC“) A/NEBO (ii) DEKÓDOVÁNÍ VIDEA AVC, KTERÉ BYLO ZAKÓDOVÁNO UŽIVATELEM PROVÁDĚJÍCÍM OSOBNÍ NEBO NEKOMERČNÍ ČINNOST NEBO KTERÉ BYLO ZÍSKÁNO OD PARTNERA, KTERÝ VLASTNÍ LICENCI NA POSKYTOVÁNÍ VIDEA AVC. NENÍ UDĚLENA LICENCE K ŽÁDNÉMU DALŠÍMU POUŽITÍ ANI JEJÍ UDĚLENÍ NELZE PŘEDPOKLÁDAT. DALŠÍ INFORMACE LZE ZÍSKAT OD SPOLEČNOSTI MPEG LA, L.L.C. NA ADRESE HTTP://WWW.MPEGLA.COM.</p>
<p><strong>Adobe</strong></p>
<p>Aplikace Google Chrome může zahrnovat další součásti poskytnuté společnostmi Adobe Systems Incorporated a Adobe Software Ireland Limited (společně „společnost Adobe“). Vaše použití softwaru společnosti Adobe poskytnutého společností Google (dále jen „Software Adobe“) se řídí následujícími doplňujícími podmínkami (dále jen „Smluvní podmínky společnosti Adobe“). Vy jako subjekt, kterému byl poskytnut Software Adobe, budete v tomto dokumentu nazýváni „Nabyvatel sublicence“.</p>
<p>1. Licenční omezení.</p>
<p>(a) Přehrávač Flash Player verze 10.x je navržen pouze jako plugin prohlížeče. Nabyvatel sublicence nesmí měnit ani distribuovat tento Software Adobe k jinému použití, než je použití pluginu prohlížeče pro přehrávání obsahu na webové stránce. Nabyvatel sublicence nesmí například měnit tento Software Adobe za tím účelem, aby umožnil spolupráci s aplikacemi spuštěnými mimo prohlížeč (např. samostatnými aplikacemi, widgety nebo uživatelským rozhraním zařízení).</p>  
<p>(b) Nabyvatel sublicence nezpřístupní žádná aplikační rozhraní přehrávače Flash Player verze 10.x prostřednictvím rozhraní pluginu prohlížeče způsobem, který by umožňoval použití tohoto rozšíření k přehrávání obsahu z webové stránky formou samostatné aplikace.</p>
<p>(c) Software Chrome Reader se nesmí používat k zobrazení dokumentů PDF nebo EPUB, které využívají jiné protokoly či systémy správy digitálních práv než Adobe DRM.</p>
<p>(d) Systém Adobe DRM musí být v softwaru Chrome Reader povolen pro všechny dokumenty PDF a EPUB chráněné systémem Adobe DRM.</p>
<p>(e) Software Chrome Reader nesmí deaktivovat žádné funkce (vyjma funkcí explicitně povolených technickými požadavky) poskytované společností Adobe v Softwaru Adobe mimo jiné včetně zde uvedených příkladů podpory formátů PDF a EPUB a systému Adobe DRM.</p>
<p>2. Elektronický přenos. Nabyvatel sublicence může umožnit stažení Softwaru Adobe z webu, internetu, intranetu nebo prostřednictvím podobné technologie (dále jen „Elektronické přenosy“). Nabyvatel sublicence však musí souhlasit s tím, že všechny jím šířené distribuce Softwaru Adobe včetně distribucí šířených na discích CD-ROM, DVD-ROM nebo jiných paměťových médiích a Elektronickými přenosy (jsou-li výslovně povoleny), budou chráněny přiměřenými bezpečnostními opatřeními proti neoprávněnému použití. Ve vztahu ke zde schváleným Elektronickým přenosům souhlasí Nabyvatel sublicence s tím, že uvede v platnost přiměřená omezení použití daná společností Adobe včetně omezení týkajících se zabezpečení nebo omezení distribuce koncovým uživatelům Produktu Nabyvatele sublicence.</p>  
<p>3. Smlouva EULA a Podmínky distribuce.</p>  
<p>(a) Nabyvatel sublicence zajistí, aby byl Software Adobe distribuován koncovým uživatelům s právně vymahatelnou licenční smlouvou s koncovým uživatelem ve prospěch Nabyvatele sublicence a jeho dodavatelů, která bude obsahovat alespoň každou z následujících minimálních smluvních podmínek (dále jen „Licence pro koncového uživatele“): (i) zákaz distribuce a kopírování, (ii) zákaz provádění změn a vytváření odvozených děl, (iii) zákaz dekompilace, zpětné analýzy, rozboru či jiných způsobů převodu Softwaru Adobe do člověkem čitelné podoby, (iv) ustanovení o tom, že vlastníkem Produktu Nabyvatele sublicence (podle definice v části 8) je Nabyvatel sublicence a jeho poskytovatelé licencí, (v) odmítnutí odpovědnosti za nepřímé, zvláštní, vedlejší, trestní a následné škody a (vi) další odmítnutí a omezení odpovědnosti obvyklá v daném odvětví, včetně případného odmítnutí všech příslušných zákonných záruk v celém rozsahu přípustném podle zákona.</p>
<p>(b) Nabyvatel sublicence zajistí, aby byl Software Adobe distributorům Nabyvatele sublicence distribuován s právně vymahatelnou licenční smlouvou o distribuci ve prospěch Nabyvatele sublicence a jeho dodavatelů, která bude obsahovat smluvní podmínky se stejným stupněm ochrany společnosti Adobe, jaký mají Smluvní podmínky společnosti Adobe.</p>  
<p>4. Otevřený zdrojový kód. Nabyvatel sublicence neudělí (ať už přímo, nepřímo nebo jen náznakem) žádné třetí straně žádná práva ani ji nezprostí žádných povinností souvisejících s duševním vlastnictvím nebo vlastnickými právy společnosti Adobe, podle kterých by se toto duševní vlastnictví stalo předmětem licence či smlouvy o otevřeném zdrojovém kódu, jejíž součástí bude požadavek či prohlášení, které by bylo možno chápat jako požadavek, že podmínkou použití, změn a/nebo distribuce Softwaru Adobe je, aby byl (i) zveřejněn nebo distribuován ve formě zdrojového kódu, (ii) licencován za účelem tvorby odvozených děl nebo (iii) bezplatně šířen. Aby nedošlo k nedorozumění: předchozí omezení nebrání Nabyvateli sublicence v distribuci Softwaru Adobe, který může Nabyvatel sublicence bezplatně distribuovat jako součást Softwaru Google.</p>
<p>5. Doplňující podmínky. S ohledem na aktualizace, upgrady a novější verze Softwaru Adobe (souhrnně „Upgrady“) poskytované Nabyvatelům sublicencí si společnost Adobe vyhrazuje právo požadovat dodržování doplňujících smluvních podmínek týkajících se pouze Upgradu a jeho budoucích verzí (a to výhradně v rozsahu, v jakém společnost Adobe vyžaduje tato omezení od všech nabyvatelů licencí na Upgrade). Pokud Nabyvatel sublicence s doplňujícími smluvními podmínkami nesouhlasí, nebude mít žádná licenční práva na Upgrade a 90 dní po datu, kdy byl informován o doplňujících smluvních podmínkách, budou automaticky ukončena jeho licenční práva na Software Adobe.</p>  
<p>6. Vlastnická práva. Nabyvatel sublicence neodstraní ani žádným způsobem nepozmění sdělení o autorských právech, ochranných známkách a vlastnictví log, související sdělení ani jiná sdělení o vlastnických právech společnosti Adobe (a jejích případných poskytovatelů licencí), která jsou součástí Softwaru Adobe nebo s ním dodaných materiálů. Nabyvatel sublicence bude požadovat splnění těchto podmínek i od svých distributorů.</p>
<p>7. Technické požadavky. Nabyvatel sublicence a jeho distributoři smějí distribuovat Software Adobe a/nebo Upgrade pouze v zařízeních, která (i) splňují technické požadavky uveřejněné na webu http://www.adobe.com/mobile/licensees (nebo na následnických webových stránkách) a (ii) která byla ověřena společností Adobe způsobem popsaným níže.</p>
<p>8. Ověření a aktualizace. Každý svůj produkt (a každou jeho verzi), který obsahuje Software Adobe nebo Upgrade (dále jen „Produkt Nabyvatele sublicence“) a který nesplňuje kritéria výjimky z ověření zařízení, která oznámí společnost Google, musí Nabyvatel sublicence odeslat společnosti Adobe k ověření. Nabyvatel sublicence zaplatí za každé odeslání tím, že si pořídí ověřovací balíčky podle aktuálně platných smluvních podmínek společnosti Adobe uvedených na webu http://flashmobile.adobe.com/. Produkt Nabyvatele sublicence, který neprošel ověřením, nesmí být distribuován. Ověření bude provedeno v souladu s aktuálně platným procesem společnosti Adobe, který je popsán na webu http://flashmobile.adobe.com/ (dále jen „Ověření“).</p>
<p>9. Centrum profilů a zařízení. Nabyvatel sublicence bude v rámci procesu Ověření nebo jiným způsobem vyzván, aby zadal určité profilové informace o Produktech Nabyvatele sublicence. Nabyvatel sublicence tyto informace společnosti Adobe poskytne. Společnost Adobe může tyto profilové informace (i) použít přiměřeným způsobem k ověření Produktu Nabyvatele sublicence (pokud je takový produkt předmětem Ověření) a (ii) zobrazit v systému „Adobe Device Intelligence“, který se nachází na webu https://devices.adobe.com/partnerportal/. Tento systém je také k dispozici prostřednictvím nástrojů a služeb společnosti Adobe pro tvorbu a vývoj a umožňuje vývojářům a koncovým uživatelům zkontrolovat, jak bude obsah a aplikace vypadat v Produktech Nabyvatele sublicence (např. jak budou v některých telefonech vypadat obrázky videí).</p>  
<p>10. Export. Nabyvatel sublicence bere na vědomí, že zákony a směrnice Spojených států omezují vývoz a opětovný vývoz komodit a technických dat pocházejících ze Spojených států, mezi které může patřit Software Adobe. Nabyvatel sublicence souhlasí s tím, že nebude vyvážet ani opětovně vyvážet Software Adobe bez příslušných souhlasů úřadů Spojených států a zahraničních státních úřadů.</p>
<p>11. Podmínky použití přenosových technologií. </p>  
<p>(a) Pokud k tomu Nabyvatel sublicence neobdržel od příslušné strany povolení, nebo s ní za tímto účelem neuzavřel smlouvu, nesmí Software Adobe používat ani povolit jeho použití ke kódování nebo dekódování pouze zvukových dat ve formátu mp3 v jiném zařízení, než je počítač (např. v mobilním telefonu nebo přijímači set-top box). Kromě toho programy pro kódování nebo dekódování obsažené v Softwaru Adobe nesmějí být použity ani zpřístupněny jiným produktem, než je Software Adobe. Software Adobe je možno použít ke kódování nebo dekódování dat ve formátu MP3 obsažených v souboru formátu swf nebo flv, který obsahuje video, obrázky nebo jiná data. Nabyvatel sublicence bere na vědomí, že použití Softwaru Adobe v nepočítačových zařízeních, jak je popsáno v ujednáních v této části, může vyžadovat úhradu licenčních poplatků nebo jiných částek třetím stranám, které mohou být vlastníky práv k duševnímu vlastnictví na technologii MP3, a že ani společnost Adobe ani Nabyvatel sublicence neuhradili žádné poplatky ani jiné částky třetí straně vlastnící práva k duševnímu vlastnictví za tento způsob použití. Pokud Nabyvatel sublicence vyžaduje program pro kódování nebo dekódování formátu MP3 pro tento způsob použití, odpovídá Nabyvatel sublicence za pořízení nezbytné licence k duševnímu vlastnictví včetně příslušných patentových práv.</p>
<p>(b) Nabyvatel sublicence nebude používat, kopírovat, reprodukovat ani upravovat (i) zdrojový kód On2 (dodaný jako součást zdrojového kódu), pomocí kterého Software Adobe dekóduje video ve formátu Flash (.flv nebo .f4v), a (ii) zdrojový kód Sorenson Spark (dodaný jako součást zdrojového kódu) za účelem pouhé opravy chyb a zvýšení výkonu Softwaru Adobe. Všechny kodeky poskytnuté se Softwarem Adobe lze používat a distribuovat pouze jako nedílnou součást Softwaru Adobe a nesmí být přístupné jiným aplikacím včetně aplikací Google.</p>  
<p>(c) Zdrojový kód může být poskytnut s kodekem AAC nebo kodekem HE-AAC (dále jen „kodek AAC“). Použití kodeku AAC je podmíněno tím, že Nabyvatel sublicence získá patřičnou patentovou licenci zahrnující nezbytné patenty poskytované společností VIA Licensing pro koncové produkty, ve kterých bude kodek AAC použit. Nabyvatel sublicence bere na vědomí a souhlasí s tím, že společnost Adobe neposkytuje patentovou licenci na kodek AAC v rámci této smlouvy Nabyvateli sublicence ani nabyvatelům jeho sublicencí.</p>
<p>(d) ZDROJOVÝ KÓD MŮŽE OBSAHOVAT KÓD, KTERÝ JE LICENCOVÁN V RÁMCI PORTFOLIA PATENTŮ AVC PRO OSOBNÍ A NEKOMERČNÍ POUŽITÍ UŽIVATELEM K TĚMTO ÚČELŮM: (i) KE KÓDOVÁNÍ VIDEA V SOULADU SE STANDARDEM AVC (DÁLE JEN „VIDEO AVC“); (ii) DEKÓDOVÁNÍ VIDEA AVC, KTERÉ BYLO ZAKÓDOVÁNO UŽIVATELEM PROVÁDĚJÍCÍM OSOBNÍ NEBO NEKOMERČNÍ ČINNOST NEBO KTERÉ BYLO ZÍSKÁNO OD POSKYTOVATELE VIDEA, KTERÝ VLASTNÍ LICENCI NA POSKYTOVÁNÍ VIDEA AVC. NENÍ UDĚLENA LICENCE K ŽÁDNÉMU DALŠÍMU POUŽITÍ ANI JEJÍ UDĚLENÍ NELZE PŘEDPOKLÁDAT. DALŠÍ INFORMACE LZE ZÍSKAT OD SPOLEČNOSTI MPEG LA, L.L.C. Viz webové stránky http://www.mpegla.com.</p>
<p>12. Aktualizace. Nabyvatel sublicence nesmí mařit snahu společností Google a Adobe o aktualizaci Softwaru Adobe ve všech produktech Nabyvatele sublicence, ve kterých je Software Adobe zahrnut jako součást Softwaru Google („Produkty Nabyvatele sublicence“).</p>  
<p>13. Informace o vlastnictví. Nabyvatel sublicence uvede Software Adobe ve veřejně dostupných specifikacích Produktu Nabyvatele sublicence a obal nebo marketingové materiály tohoto produktu opatří odpovídajícími značkami Softwaru Adobe (s výjimkou loga společnosti Adobe) obdobným způsobem, jako jsou uvedeny značky jiných produktů třetích stran, které produkt obsahuje.</p>
<p>14. Odmítnutí záruky. SOFTWARE ADOBE JE POSKYTOVÁN NABYVATELI SUBLICENCE K POUŽITÍ A REPRODUKCI VE STAVU „JAK JE“ A SPOLEČNOST ADOBE NEPOSKYTUJE ŽÁDNÉ ZÁRUKY NA JEHO POUŽITÍ NEBO VÝKON. SPOLEČNOST ADOBE A JEJÍ DODAVATELÉ NERUČÍ ANI NEMOHOU RUČIT ZA VÝKON SOFTWARU ADOBE NEBO VÝSLEDKY ZÍSKANÉ JEHO POUŽITÍM. S VÝJIMKOU ZÁRUK, PROHLÁŠENÍ, VYJÁDŘENÍ NEBO SMLUVNÍCH PODMÍNEK V ROZSAHU, V JAKÉM JE NENÍ MOŽNO NEBO NENÍ POVOLENO VYLOUČIT NEBO OMEZIT PODLE PLATNÝCH ZÁKONŮ V JURISDIKCI NABYVATELE SUBLICENCE, SPOLEČNOST ADOBE A JEJÍ DODAVATELÉ NEPOSKYTUJÍ ŽÁDNÉ ZÁRUKY, PROHLÁŠENÍ, VYJÁDŘENÍ ANI SMLUVNÍ PODMÍNKY (VÝSLOVNÉ ČI PŘEDPOKLÁDANÉ, AŤ UŽ VYPLÝVAJÍ ZE STATUTÁRNÍHO ČI OBYČEJOVÉHO PRÁVA, ZVYKLOSTÍ, OBVYKLÉ PRAXE NEBO JINÝCH PODMÍNEK) TÝKAJÍCÍ SE JAKÉKOLIV ZÁLEŽITOSTI VČETNĚ, MIMO JINÉ, NEPOŠKOZENÍ PRÁV TŘETÍCH STRAN, OBCHODOVATELNOSTI, INTEGRACE, USPOKOJIVÉ KVALITY NEBO VHODNOSTI PRO KONKRÉTNÍ ÚČEL. NABYVATEL SUBLICENCE SOUHLASÍ S TÍM, ŽE NEBUDE POSKYTOVAT ŽÁDNÉ ZÁRUKY, VÝSLOVNÉ ANI PŘEDPOKLÁDANÉ, V ZASTOUPENÍ SPOLEČNOSTI ADOBE.</p>  
<p>15. Omezení odpovědnosti. SPOLEČNOST ADOBE ANI JEJÍ DODAVATELÉ NEBUDOU ZA ŽÁDNÝCH OKOLNOSTÍ NÉST ODPOVĚDNOST VŮČI NABYVATELI SUBLICENCE ZA PŘÍPADNÉ ŠKODY, NÁROKY NEBO NÁKLADY JAKÉHOKOLIV DRUHU ANI ŽÁDNÉ NÁSLEDNÉ, NEPŘÍMÉ ČI VEDLEJŠÍ ŠKODY ČI ZTRÁTY NA ZISKU NEBO ÚSPORÁCH, I KDYŽ BY BYL ZÁSTUPCE SPOLEČNOSTI ADOBE UPOZORNĚN NA MOŽNOST VZNIKU TOHOTO DRUHU ZTRÁT, ŠKOD, NÁROKŮ ČI NÁKLADŮ, A NEBUDOU MÍT ANI ODPOVĚDNOST ZA ŽÁDNÉ NÁROKY VZNESENÉ TŘETÍ STRANOU. PŘEDCHOZÍ OMEZENÍ A VYLOUČENÍ JSOU PLATNÁ V ROZSAHU, V JAKÉM JE POVOLUJÍ PLATNÉ ZÁKONY V JURISDIKCI NABYVATELE SUBLICENCE. CELKOVÁ ODPOVĚDNOST SPOLEČNOSTI ADOBE A JEJÍCH DODAVATELŮ V RÁMCI TÉTO SMLOUVY NEBO V SOUVISLOSTI S NÍ BUDE OMEZENA ČÁSTKOU JEDEN TISÍC AMERICKÝCH DOLARŮ (1000 USD). Žádná část této Smlouvy neomezuje odpovědnost společnosti Adobe vůči Nabyvateli sublicence v případě smrti nebo zranění osob vyplývajících z nedbalosti či podvodu ze strany společnosti Adobe. Společnost Adobe zastupuje své dodavatele v záležitostech odmítnutí odpovědnosti, vyloučení nebo omezení závazků, záruk a hmotné odpovědnosti, které jsou uvedeny v této Smlouvě. Nezastupuje je v žádných dalších ohledech ani za žádným jiným účelem.</p>
<p>16. Podmínky ochrany obsahu</p>
<p>(a) Vymezení pojmů.</p>
<p>„Pravidla souladu a robustnosti“ označují dokument, který definuje pravidla pro soulad a robustnost Softwaru Adobe umístěná na webové stránce http://www.adobe.com/mobile/licensees nebo následnických webových stránkách.</p>
<p>„Funkce ochrany obsahu“ jsou aspekty Softwaru Adobe, které slouží k zajištění dodržení Pravidel souladu a robustnosti a zamezení přehrávání, kopírování, úprav, opětovné distribuce nebo dalších činností týkajících se digitálního obsahu za účelem užití uživateli Softwaru Adobe, pokud tyto činnosti nejsou povoleny vlastníky daného digitálního obsahu nebo jeho licencovanými distributory.</p>
<p>„Kód pro ochranu obsahu“ označuje kód v některých verzích Softwaru Adobe, který aktivuje některé funkce ochrany obsahu.</p>
<p>„Klíč“ označuje kryptografickou hodnotu obsaženou v Softwaru Adobe, která slouží k dešifrování digitálního obsahu.</p>
<p>(b) Licenční omezení. Na právo Nabyvatele sublicence využívat licence k Softwaru Adobe se vztahují následující další omezení a závazky. Nabyvatel sublicence zajistí, aby jeho zákazníci dodržovali tato omezení a závazky ve stejném rozsahu, v jakém je to požadováno od Nabyvatele sublicence ve vztahu k Softwaru Adobe. Jakékoliv nedodržení těchto dalších omezení a závazků ze strany zákazníků Nabyvatele sublicence bude považováno za zásadní porušení smlouvy Nabyvatelem sublicence.</p>
<p>b.1. Nabyvatel sublicence a jeho zákaznici mohou distribuovat pouze takový Software Adobe, který splňuje Pravidla souladu a robustnosti, což bude potvrzeno Nabyvatelem sublicence během procesu ověření popsaného výše ve Smluvních podmínkách společnosti Adobe.</p>   
<p>b.2. Nabyvatel sublicence nebude (i) obcházet Funkce ochrany obsahu v Softwaru Adobe nebo v jakémkoliv souvisejícím Softwaru Adobe, které slouží k šifrování nebo dešifrování digitálního obsahu za účelem autorizovaného užití uživateli Softwaru Adobe a (ii) vyvíjet či distribuovat produkty, které slouží k obcházení Funkcí ochrany obsahu v Softwaru Adobe nebo v jakémkoliv souvisejícím Softwaru Adobe, které slouží k šifrování nebo dešifrování digitálního obsahu za účelem autorizovaného užití uživateli Softwaru Adobe.</p>
<p>(c) Klíče jsou považovány za důvěrné informace společnosti Adobe a Nabyvatel sublicence bude ve vztahu ke Klíčům dodržovat postup zacházení se zdrojovým kódem Adobe (který společnost Adobe na požádání poskytne).</p>  
<p>(d) Soudně nařízený opravný prostředek. Nabyvatel sublicence souhlasí s tím, že porušení této Smlouvy může ohrozit Funkce ochrany obsahu v Softwaru Adobe a může způsobit ojedinělé a trvalé poškození zájmů společnosti Adobe a vlastníků digitálního obsahu, kteří na tyto Funkce ochrany obsahu spoléhají, a že finanční odškodné nemusí být k úplné kompenzaci těchto škod dostatečné. Nabyvatel sublicence proto dále souhlasí s tím, že společnost Adobe má právo kromě finančního odškodného vyžadovat soudně nařízený nápravný prostředek, aby eliminovala nebo omezila škody způsobené příslušným porušením smlouvy.</p>
<p>17. Určená oprávněná třetí strana. Společnosti Adobe Systems Incorporated a Adobe Software Ireland Limited jsou určenými oprávněnými třetími stranami smlouvy mezi společností Google a Nabyvatelem sublicence ve věci Softwaru Adobe včetně mimo jiné Smluvních podmínek společnosti Adobe. Nabyvatel sublicence souhlasí bez ohledu na rozpor v této smlouvě se společností Google, že společnost Google smí zveřejnit identitu Nabyvatele sublicence společnosti Adobe a písemně osvědčit, že Nabyvatel sublicence uzavřel se společností Google licenční smlouvu, která zahrnuje Smluvní podmínky společnosti Adobe. Nabyvatel sublicence musí uzavřít smlouvu se všemi nabyvateli jeho licencí a pokud mají tito nabyvatelé licence povoleno opětovně distribuovat Software Adobe, musí být součástí jejich smlouvy také Smluvní podmínky společnosti Adobe.</p>
</body>
</html>
