MIME-Version: 1.0Content-Type: multipart/related; boundary="----=_NextPart_ZROIIZO.ZCZYUACXV.ZARTUI"------=_NextPart_ZROIIZO.ZCZYUACXV.ZARTUIContent-Location: file:///C:/mydocument.htmContent-Transfer-Encoding: base64Content-Type: text/html; charset="utf-8"<html xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:w="urn:schemas-microsoft-com:office:word" xmlns="http://www.w3.org/TR/REC-html40">

        <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
        <meta http-equiv="Content-Encoding" content="UTF-8" />

        <head>
            <title></title>
                <link rel="File-List" href="mydocument_files/filelist.xml" />
                <style type="text/css">
                    /* Modified by Sandra Gorgan on Jan 17th 2011 - All fonts default start with Arial *//* Set the font explicit for html elments to avoid IE6 problems*/div, html, body,td, em {    font-family: arial, tahoma, trebuchet ms, arial, sans-serif;    font-size: 10pt;}/* CSS Styles for document and results list display */.document-fragment b.monitor_attention {    display: none;}del *, strike *, s * {    text-decoration: line-through;}ins * {    text-decoration: underline;}.document-fragment-selected b.monitor_attention {    display: inline;}#content-panel .doc table p {    text-indent: 0;}#content-panel .doc li p, #content-panel .doc ul p, #content-panel .doc ol p {    text-indent: 0;}img.portrait {	margin: 2px 6px 6px 2px;}#content-panel .doc p {    /*text-align: center;*/    line-height: 12pt;    font-size: 10pt;}/* added Sandra Gorgan - 15.06.2012 - authors in books */#content-panel .doc p.author {	text-align: center!important;}#content-panel .doc p.autor {	margin-bottom: 20px;    margin-left: 2%;}#content-panel .doc p.autor-cj {    background: url("/legalis/seam/resource/products/icon-autor-cj.png") no-repeat scroll left 0 rgba(0, 0, 0, 0);    margin: 10px 0 0 15px;    min-height: 35px;    padding-left: 30px;    padding-top: 10px;}/* added Sandra Gorgan - 11.01.2011 - more styling in Monitorul Oficial titles */#content-panel .doc p.law-type {    font-family: Georgia, arial, sans-serif;    text-align: center;    line-height: 14pt;    font-size: 12pt;}#content-panel .doc p.mocit {    font-family: arial, tahoma, trebuchet ms, arial, sans-serif;    text-align: center;    line-height: 14pt;    font-size: 10pt;    text-indent: 12pt;}#content-panel .doc p.legislator {    font-family: arial, tahoma, trebuchet ms, arial, sans-serif;    text-align: center;    line-height: 14pt;    font-size: 10pt;    text-indent: 12pt;}div.legislator {    margin-bottom: 6pt;    margin-top: 10pt;    text-align: center;}/* end addition */#right-tree-panel .doc p {    padding-bottom: 5px;}a {    text-decoration: none;    color: #990000;}a:hover {    text-decoration: underline;    color: #444;}a.cf-law-art  {color:#333333;}a.ctr-dld {	background: url("https://www.legalis.ro/img/dld.png") no-repeat scroll 0 0 transparent;    font-style: italic;    font-weight: bold;    padding-left: 25px;}sup.fnt {    float: left;}.floating-body {    margin-top: 20pt;}.floating-body .subtoc .tile {    line-height: 3pt;}#right-tree-panel .floating-body {    margin-top: 10pt;}.subtoc {    margin-top: 6pt;    margin-bottom: 6pt;}.subtoc p.title {    text-align: center;}body.assembly .subtoc {    display: none;}a.pagina:hover {    text-decoration: none;    color: black;}a.pagina {    text-decoration: none;    color: black;}.doc {}#content-panel .doc p {    text-align: justify;    line-height: 12pt;    font-size: 10pt;	padding-left: 2%;    padding-right: 2%;}/* Add more styling to CEDO decisions - S Gorgan 1 Aug 2011 */#content-panel .doc p.citationline {    text-align: center;    font-weight: bold;}.pastila p {    font-style: italic;    padding: 4px 0;}/* end of style */#content-panel div.bulk_act_title  p.type {	font-family: Georgia,Arial,sans-serif;    font-size: 14pt;    line-height: 16pt;    margin-bottom: 5pt;    margin-top: 8pt;    text-align: center;}.doc div {    font-size:12px;}/* Add styling for online commentaries - Author Sandra Gorgan - 06.04.2012 */.doc div.law-correlation {	background: url("http://www.legalis.ro/img/corelatii1.png") no-repeat scroll left center transparent;	margin-left: 15px;	padding: 5px 0 5px 10px;	}.doc div.law-comment {    background-color: #F1F1F1;    margin:10px 2% 0;    padding: 5px 0;	}#content-panel .doc p.comm {	font-size: 11pt;    font-weight: bold;}/*Add styling for updated commentaries - Author Sandra Gorgan - 18.05.2012 */.doc div.law-comment p.comm-update {	background: url("http://www.legalis.ro/legalis/theme/version_ro/images/plusboxbig.png") no-repeat scroll 0 0 transparent;    margin: 2%;    padding-left: 3%!important;}/* More styles for decisions in MO - Author Sandra Gorgan - 17.01.2011 */#content-panel .doc div.issuer p {    text-align: center;    font-weight: bold;}#content-panel .doc div.cc_title p {    text-align: center;   }/* end of new code */.hitlist-link {    color: #990000;}.hitlist-invalid-link {    color: #907070;}.hl-inner-entry {    margin-left: 30px;    font-weight: bold;    color:#333;}.group-documents {	margin-left: 30px;}.group-documents .hl-inner-entry{	margin-left: 0;	padding-left: 10px;}	/* Added Sandra Gorgan - Mar 2nd 2011 - new links in documents */.legal-text>a {	text-decoration: underline;}a.results-list-group-more {    color:#990000;    font-size: 8pt;}.hl-related-inner-entry {    margin-bottom: 2px;    margin-top: 2px;    text-indent: 0;    font-size: 11px;}.hl-related-inner-entry p {    margin-bottom:2px;    margin-top:2px;}/* Results list texts */p.creator {    margin: 0 0 0 20px;    font-style: italic;    text-indent: 0;    position: relative;    left: -20px;    font-size: 7.5pt;}.hl-inner-entry p.creator {   font-size: 7.5pt;   color: #333;}.hl-inner-entry p.citation {  font-size: 7.5pt;  padding-top: 4px;  padding-bottom: 3px;}.hl-inner-entry p.hitlist {	margin:2px 0 3px;}p.results_title {    margin: 0;    font-weight: bold;    text-indent: 0;    display: inline;}p.results_title a.hitlist-link{    color: #222222;}p.abstract {    font-weight:normal;    margin: 0;}p.citation {    margin: 0;    text-indent: 0;}p.related-citation {    margin-top: 0;    text-indent: 0;    text-align: left;    padding-right: 20px;}p.related-citation-no-clock-me {    margin-top: 0;    text-indent: 0;    text-align: left;    padding-right: 20px;    background-image: url(/legalis/images/no-clock-me.gif );    background-position: right top;    background-repeat: no-repeat;}p.related-citation-clock-me {    margin-top: 0;    text-indent: 0;    text-align: left;    padding-right: 20px;    background-image: url(/legalis/images/clock-me.gif );    background-position: right top;    background-repeat: no-repeat;}.group-title-link {	color:#333333 !important;	text-decoration: underline;	}/* Toc citation */p.toc_citation_title {    color:#333333;    padding:0 0 5px;    font-weight: bold;    text-indent: 0;}p.toc_citation_citationline {    margin: 0;    text-indent: 0;}/* Special style for documents outside user subscription */.no-subscription {}/* Valid results list entry */.results-invalid {    color: #808080;}div.results-invalid a {    color: #907070;}/* CSS Rules for results list images, based on document class */img.dt-legal-rule {    background-image: url(/legalis/seam/resource/products/ico_dt_legal_rule.jpg );}img.dt-mo {    background-image: url(/legalis/seam/resource/products/ico_dt_legal_rule.jpg );}img.invalid-dt-mo {    background-image: url(/legalis/seam/resource/products/ico_dt_legal_rule.jpg );}/* News */img.dt-news {    background: transparent url(/legalis/seam/resource/products/ico_stiri.png ) no-repeat scroll center center;}img.dt-bshop {    background: url("/legalis/seam/resource/products/ico_bshop.gif") no-repeat scroll center center transparent;}/* Bibliography */img.dt_bibliography {    background: transparent url(/legalis/seam/resource/products/ico_dt_bibliography.gif) no-repeat scroll center center;}/* MO Adnotat */img.dt-comment {    background: transparent url(/legalis/seam/resource/products/ico_dt_mo_adnotat.jpg )  no-repeat scroll center center;}img.invalid-dt-legal-rule {    background-image: url(/legalis/seam/resource/products/ico_inv_dt_legal_rule.jpg );}img.dt-eu-legislation {    background-image: url(/legalis/seam/resource/products/ico_dt_eu_legislation.jpg );}img.invalid-dt-eu-legislation {    background-image: url(/legalis/seam/resource/products/ico_inv_dt_eu_legislation.jpg );}img.dtd-decision {    background-image: url(/legalis/seam/resource/products/ico_dtd_decision.jpg );}img.invalid-dtd-decision {    background-image: url(/legalis/seam/resource/products/ico_inv_dtd_decision.jpg );}img.dtd-decision-cedo {    background-image: url(/legalis/seam/resource/products/ico_dtd_decision.jpg );}img.invalid-dtd-decision-cedo {    background-image: url(/legalis/seam/resource/products/ico_inv_dtd_decision.jpg );}img.dt-books {    background-image: url(/legalis/seam/resource/products/ico_book.jpg );}img.invalid-dt-books {    background-image: url(/legalis/seam/resource/products/ico_inv_book.jpg );}img.dt-breviar {    background-image: url(/legalis/seam/resource/products/ico_breviar.png );}img.dt-editorial {    background-image: url(/legalis/seam/resource/products/ico_editorial.png );}img.dt-comment {    background-image: url(/legalis/seam/resource/products/ico_mo_adnotat.png );}img.book-cover {    background-repeat: repeat-y;    background-position: left;}.Bibliografie_selectiva {    font-size: 8pt;    margin-bottom: 12pt;}.Bibliografie_selectiva p {    text-indent: 0;}.Bibliografie {    font-size: 8pt;    margin-bottom: 12pt;}.Bibliografie p {    text-indent: 0;}p.liniuta {    margin-left: 12pt;    text-indent: -12pt;}/* HEADINGS */h1 {	font-size: 11pt;	margin-top: 12pt;	margin-bottom: 12pt;}h1.title {	font-size: 12pt;	margin: 12pt 5%;}h1.tips , h1.editorial, h1.bshop-title{	font-size: 11pt;	margin: 12pt 0!important;	text-align: center;}h2 {	font-size: 10pt;	margin-top: 9pt;	margin-bottom: 4pt;}h3 {	font-size: 9pt;	margin: 6pt 3%;}p.h1 {    font-weight: bold;    text-indent: 0;    margin-top: 12pt;}p.h2 {    font-style: italic;    text-indent: 0;}p.space-before {    margin-top: 12pt;}div.indent {    margin-left: 12pt;    font-size: 9pt;}div.indent p {    text-indent: 0;}.Exemplu {    font-size: 8pt;    border: 1px solid #d0d0d0;    padding: 3pt;}.Exemplu p {    text-indent: 0;}em.heading {    font-weight: bold;    font-style: normal;}em.bold {    font-weight: bold;    font-style: normal;}em.italic {    font-style: italic;}p.punct {    margin-top: 18pt;    text-indent: 0;}p.litera_mare {    margin-top: 12pt;    text-indent: 0;}div.title {    text-align: center;    margin-top: 7pt;    margin-bottom: 5pt;}div.title p {    font-weight: bold;    text-indent: 0;    text-align: center;}div.title div.title {    margin-top: 0;    margin-bottom: 0;}div.title p.law-type {    font-family: Arial, sans-serif;    font-size: 24pt;    line-height: 24pt;    text-align: center;    margin-top: 24pt;}#content-panel div.title div.titletext p {    font-family: Arial, sans-serif;    font-size: 12pt;    font-weight: normal;    text-align: center;}#content-panel div.title p.legislator {    font-family: Arial, sans-serif;    font-size: 12pt;    font-weight: normal;    text-align: center;}/* changed family, sizes, margin - Sandra Gorgan - Feb 2nd, March 9th 2011 */#content-panel div.titletext p {    font-family: Georgia,Arial,sans-serif;    font-size: 14pt;    line-height: 16pt;    margin-bottom: 10pt;    margin-top: 8pt;    text-align: center;}/* end changes */#content-panel div.h p {    text-indent: 0;    text-align: center;    font-weight: bold;    margin-bottom: 6pt;    margin-top: 12pt;}#content-panel div.h div.titletext p {    font-family: arial,tahoma,trebuchet ms,arial,sans-serif;    font-size: 12pt;    line-height: 14pt;    text-align: center;}p.title {    text-indent: 0;    text-align: left;}#content-panel .fixed-footer {    border-top: 1px solid #d0d0d0;}#content-panel .fixed-footer p.author {    text-indent: 0;    text-align: center;    font-style: italic;}#content-panel .fixed-header {    border-bottom: 1px solid #d0d0d0;}.fixed-header h1 {    margin: 3pt;    text-indent: 0;    text-align: center;}p.author {    margin-top: 12pt;    padding-top: 3pt;    border-top: 1px solid #d0d0d0;    text-indent: 0;    text-align: center;    font-style: italic;}div.abstract {    font-weight: bold;    margin-top: 12pt;    margin-bottom: 12pt;    padding-top: 6pt;    padding-bottom: 12pt;    border-top: 1px solid gray;    border-bottom: 1px solid gray;}#right-tree-panel div.abstract {   padding-bottom: 2pt;}/* Help styles */table.help1 {    font-family: Verdana, Arial, Helvetica, Sans Serif;    font-size: 7pt;}p.help1 {    padding-top: 2px;    padding-bottom: 2px;    margin: 0;    font-size: 8pt;}h1.help1 {    margin-top: 0;    margin-right: 0;    margin-left: 0;    margin-bottom: 6px;    padding-top: 6px;    padding-bottom: 6px;    font-size: 12pt;}h2.help1 {    margin: 0;    font-size: 11pt;}h3.help1 {    font-size: 8.5pt;    margin-bottom: 3pt;    margin-top: 3pt;}div.innerelement {    margin: 0;    padding: 0;    margin-left: 16px;}div.outerelement {    margin-top: 6px;    margin-bottom: 6px;}a.help1 {    color: #000080;    text-decoration: none;}a.help1:hover {    color: #0000f0;    text-decoration: none;}a.linkext {    color: #800000;    text-decoration: none;}a.linkext:hover {    color: #f00000;    text-decoration: none;}a img {    border: 0;}b.error {    color: #800000;    font-weight: normal;}ul.help1 {    margin-left: 0;    padding-left: 5px;}table.help1 {    padding: 0;}td.help1 {    vertical-align: top;}.relevance-background {    float: left;    position: relative;    height: 3px;    top: 24px;    width: 20px;    left: -25px;    background: #C0C0C0 none repeat scroll 0;}.relevance-foreground {    background-attachment: scroll;    background-color: #800000;    background-image: none;    background-repeat: repeat;    display: block;    font-size: 0;    height: 3px;}/* Frontpage styles */#content-panel .lazi-frontpage {    font-size: 11pt;    font-family: arial, sans-serif;    text-align: right;    margin-left: 10px;    margin-right: 10px;}#content-panel .lazi-frontpage div.text {    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    padding-left: 5%;    padding-right: 5%;}#content-panel .lazi-frontpage div.text p.law-list {    font-size: 10pt;    font-family: Arial, sans-serif;    margin-top: 0;    text-indent: 0;    text-align: justify;    text-align-last: right;    line-height: 16pt;}#content-panel .lazi-frontpage div.text p.note {    font-size: 10pt;    font-family: arial, sans-serif;    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    text-align: justify;}#content-panel .lazi-frontpage p.griffin {    text-align: right;    padding-left: 10%;    padding-right: 10%;}#content-panel .lazi-frontpage div.title {    border-top: 3px solid #800000;    border-bottom: 3px solid #800000;    margin-top: 12pt;    margin-bottom: 12pt;    padding-left: 10%;    padding-right: 10%;}#content-panel .lazi-frontpage div.title h1 {    font-size: 20pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 3pt;    margin-bottom: 3pt;}   #content-panel .lazi-frontpage div.title h2 {    font-size: 14pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 0;    margin-bottom: 3pt;}p {    /*text-indent: 12pt;*/    text-align: left;    margin-bottom: 3pt;    margin-top: 3pt;}table {    font-size: 10pt;}table p {    text-indent: 0;    text-align: left;    margin: 0;}div.title h1 {    margin-top: 2pt;    margin-bottom: 2pt;}div.title h1.line-1, h2.line-2 {    margin: 5pt 5%;}#content-panel .doc {    color: #333333;    font-family: inherit, sans-serif;    font-weight: normal;    text-align: center;}#content-panel .doc p.book_title {    color: #333333;    font-size: 14pt;    font-weight: bold;    text-align: center;    line-height: 18pt;}#content-panel .doc p.book_author {    color: #333333;    font-size: 10pt;    text-align: center;}/** autor cj **/#content-panel .doc p.autor {    background: url("/legalis/seam/resource/products/icon-autor-cj.png") no-repeat scroll left 0 rgba(0, 0, 0, 0);    margin: 10px 0 0 15px;    min-height: 35px;    padding-left: 30px;    padding-top: 10px;}p.griffin {    text-align: right;}#content-panel div.fn div.frontpage {    font-size: 8pt;}#content-panel .Bibliografie_selectiva {    font-size: 8pt;    margin-bottom: 12pt;}#content-panel .Bibliografie_selectiva p {    text-indent: 0;}#content-panel .Bibliografie {    font-size: 8pt;    margin-bottom: 12pt;}#content-panel .Bibliografie p {    text-indent: 0;}#content-panel div.modif {    margin-top: 20pt;    padding-top: 8pt;    background: url(/legalis/seam/resource/products/fn-line.gif ) no-repeat top left;}#content-panel div.modif p {    font-size: 7pt;    text-indent: 0;}#content-panel div.modif h2 {    font-size: 8pt;    text-indent: 0;    text-align: left;    margin: 0 0 0 2%;}#content-panel .jurispr-frontpage {    font-size: 11pt;    font-family: arial, sans-serif;    text-align: right;    margin-left: 10px;    margin-right: 10px;}#content-panel .jurispr-frontpage div.text {    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    padding-left: 10%;    padding-right: 10%;}#content-panel .jurispr-frontpage div.text p.note {    font-size: 8pt;    font-family: arial, sans-serif;    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    text-align: justify;}#content-panel .jurispr-frontpage div.title {    border-top: 3px solid #800000;    border-bottom: 3px solid #800000;    margin-top: 12pt;    margin-bottom: 12pt;    padding-left: 10%;    padding-right: 10%;}#content-panel .jurispr-frontpage div.title h1 {    font-size: 26pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 3pt;    margin-bottom: 3pt;}#content-panel .jurispr-frontpage div.title h2 {    font-size: 14pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 0;    margin-bottom: 3pt;}#content-panel .jurispr-frontpage p.griffin {    text-align: right;    padding-left: 10%;    padding-right: 10%;}#content-panel .mo-frontpage {    font-size: 11pt;    font-family: arial, sans-serif;    text-align: right;    margin-left: 10px;    margin-right: 10px;}#content-panel .mo-frontpage div.text {    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    padding-left: 10%;    padding-right: 10%;}#content-panel .mo-frontpage div.text p.note {    font-size: 8pt;    font-family: arial, sans-serif;    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    text-align: justify;}#content-panel .mo-frontpage div.title {    border-top: 3px solid #800000;    border-bottom: 3px solid #800000;    margin-top: 12pt;    margin-bottom: 12pt;    padding-left: 10%;    padding-right: 10%;}#content-panel .mo-frontpage div.title h1 {    font-size: 26pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 3pt;    margin-bottom: 3pt;}#content-panel .mo-frontpage div.title h2 {    font-size: 14pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 0;    margin-bottom: 3pt;}#content-panel .mo-frontpage p.griffin {    text-align: right;    padding-left: 10%;    padding-right: 10%;}#content-panel .eurlex-frontpage {    font-size: 11pt;    font-family: arial, sans-serif;    text-align: right;    margin-left: 10px;    margin-right: 10px;}#content-panel .eurlex-frontpage div.note {    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    padding-left: 10%;    padding-right: 10%;}#content-panel .eurlex-frontpage div.title {    border-top: 3px solid #000080;    border-bottom: 3px solid #000080;    background: #f0f0ff url(/legalis/seam/resource/products/bg-eu.png ) no-repeat top left;    margin-top: 12pt;    margin-bottom: 12pt;    padding-left: 10%;    padding-right: 10%;}#content-panel .eurlex-frontpage div.title h1 {    font-size: 20pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 3pt;    margin-bottom: 3pt;}#content-panel .eurlex-frontpage div.title h2 {    font-size: 14pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 0;    margin-bottom: 3pt;}#content-panel .eurlex-frontpage div.text p.note {    font-size: 8pt;    font-family: arial, sans-serif;    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    text-align: justify;}#content-panel .eurlex-frontpage p.griffin {    text-align: right;    padding-left: 10%;    padding-right: 10%;}#content-panel .frontpage {    font-size: 20pt;    font-family: arial, sans-serif;    text-align: center;    /*margin-left: 10px;    margin-right: 10px;*/}#content-panel .frontpage div.title h1 {    font-size: 26pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 3pt;    margin-bottom: 3pt;}#content-panel .frontpage div.title h2 {    font-size: 14pt;    font-family: Arial, sans-serif;    text-align: right;    margin-top: 0;    margin-bottom: 3pt;}#content-panel .frontpage div.text p.note {    font-size: 8pt;    font-family: arial, sans-serif;    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    text-align: justify;}#content-panel .eurlex-frontpage div.text p.note {    font-size: 11pt;    font-family: arial, sans-serif;    margin-top: 6pt;    margin-bottom: 6pt;    text-indent: 0;    text-align: justify;}/* Print media styles */@media print {table.nav {    display: none;}body {    font-family: Arial, sans-serif;}@page {    margin: 3cm;}@page:first{    margin-right: 5cm;}@page:left{    margin-left: 5cm;}@page:right{    margin-right: 5cm;}}/* latest css stuff */#content-panel .frontpage div.law-title div.titletext p {    font-family: Arial, sans-serif;    font-size: 12pt;    font-weight: normal;    text-align: center;}#content-panel .frontpage div.law-title p.legislator {    font-family: Arial, sans-serif;    font-size: 12pt;    font-weight: normal;    text-align: center;}#content-panel .frontpage div.law-title p.mocit {    font-family: Arial, sans-serif;    font-size: 10pt;    margin-top: 25pt;    font-weight: normal;    text-align: center;}#content-panel .frontpage div.law-title h2.title_line_2 , h2.title_line_3{    font-family: Arial, sans-serif!important;    font-size: 12pt!important;    font-weight: normal;	padding-left:8%;	padding-right:8%;    text-align: center!important;}/* changed font family and size  - Sandra Gorgan - Feb 2nd 2011 */#content-panel .frontpage div.law-title p.law-type {    font-family: Georgia, Arial, sans-serif;    font-size: 18pt;    line-height: 20pt;    text-align: center;    margin-top: 15pt;}/* end of change */#content-panel .frontpage div.law-title div.final {    margin-top: 24pt;    margin-bottom: 24pt;    margin-left: 50%;}#content-panel .frontpage div.law-title div.final p {    text-indent: 0;}#content-panel div.final {    margin-top: 24pt;    margin-bottom: 24pt;    margin-left: 50%;}#content-panel div.final p {    text-indent: 0;}#content-panel table.modif {    margin-top: 24pt;    margin-bottom: 24pt;    font-size: 8pt;}#content-panel table.modif th {    text-align: center;}#content-panel table.modif td.num {    width: 4%;    vertical-align: top;    text-align: center;    padding-right: 5px;}#content-panel table.modif td.title {    width: 37%;    vertical-align: top;    text-align: left;}#content-panel table.modif td.date {    width: 12%;    vertical-align: top;    text-align: center;}#content-panel table.modif td.src {    width: 10%;    vertical-align: top;    text-align: center;}#content-panel table.modif td.dest {    width: 37%;    vertical-align: top;    text-align: left;}table.modif td.num, table.modif td.title, table.modif td.date, table.modif td.src, table.modif td.dest, table.modif td.dest .num {    font-size:8pt;}div.legal_citation {    font-style: italic;    margin-left: 10mm;    margin-right: 10mm;}#content-panel div.legal_citation div.titletext p {    font-family: Arial, sans-serif;    font-size: 11pt;    text-align: center;    margin-top: 9pt;    margin-bottom: 9pt;}#content-panel div.dtd-decision div {    margin-top: 18pt;    margin-bottom: 18pt;}#content-panel div.dtd-decision div.issuer p {    text-indent: 0;    text-align: center;    font-size: 14pt;    font-family: Arial, sans-serif;    margin-top: 0;    margin-bottom: 0;}#content-panel div.dtd-decision div.cc_title {    margin-top: 18pt;    margin-bottom: 18pt;    text-indent: 0;    text-align: center;}#content-panel div.dtd-decision div.cc_title p {    text-indent: 0;    text-align: center;    font-size: 14pt;    font-family: Arial, sans-serif;    margin: 0;}#content-panel div.dtd-decision div.cc_title p.type {    font-size: 24pt;    font-family: Arial, sans-serif;}#content-panel div.dtd-decision div.judges {    margin-bottom: 18pt;}#content-panel div.dtd-decision div.judges p {    text-indent: 0;    text-align: center;    font-size: 10pt;    margin: 0;}#content-panel div.dtd-decision div.final_disposition {    margin-top: 18pt;    margin-bottom: 18pt;}#content-panel div.dtd-decision div.final_disposition p {    text-indent: 0;    text-align: center;    font-size: 10pt;    margin-top: 0;    margin-bottom: 0;}#content-panel div.dtd-decision div.desident_opinions {    border-top: 1px solid #c0c0c0;    padding-top: 18pt;}#content-panel div.dtd-decision div.desident_opinions div.titletext p {    font-size: 14pt;    font-family: Arial, sans-serif;}.related-area-main-panel .floating-body p, .related-area-main-panel .floating-body .doc p {    font-size: 11px;    text-align: left;}.related-area-main-panel .floating-body .doc em {    font-size: 11px;	font-style: italic;}.related-area-main-panel .teaser p {    font-size: 11px;    font-weight:bold;    text-align: left;}.related-area-main-panel h1.related-overview {    font-size: 16px;    margin: 6px 0 0;}.related-area-main-panel h2.related-overview {    font-size: 14px;    margin: 18px 0 0;}.related-area-main-panel h3.related-overview {    font-size:13px;    margin:9px 0 0;}.related-area-main-panel p.creator {    margin-bottom: 2px;    margin-top: 2px;    text-indent: 0;}.related-area-main-panel p.results_title {    margin: 2px 0;    font-size: 11px;}.related-area-main-panel p.abstract {    margin-bottom: 2px;    margin-top: 2px;    text-align: left;    font-size: 11px;}.related-area-main-panel p.citation a.hitlist-link {    color: #800000;    font-size: 10px;    text-align: right;    margin-bottom: 2px;    margin-top: 2px;    text-indent: 0;}.related-area-main-panel a.more-link {    color: #800000;    font-size: 10px;    text-align: right;    margin-bottom: 2px;    margin-top: 2px;    text-indent: 0;}#content-panel p.abrogat {    font-weight: bold;    text-align: center;    color: #CC0000;}div.doc ol, div.doc ul {    padding-left: 30px;    text-align: left;}.searchResultsNav{    vertical-align:inherit!important;    *vertical-align:text-bottom!important;}.documentCount{    font-size: 11px;    }/* Hide description in related area for news and mo adnotat items */#main-form\:content-related_body div.dt-news p.abstract {	display: none;}#main-form\:content-related_body div.dt-comment p.abstract {	display: none;}/* end of added code *//* style for saved searches -edit SG March 29, 2011*/.history-search-term {	font-weight: bold;}/* styling the image and caption in the editorial, bshop S Gorgan Jul 20th 2011 / May 10th 2012*/.editorial-image, .bshop-image {    background: none repeat scroll 0 0 #F3F3F3;    border: 1px solid #DEDEDE;    float: left;    height: 100%;    margin: 0 10px 5px 0;    width: 120px;}.editorial-image, .bshop-image img{    padding: 5px !important;}.ed-extra-img {    float: left;    margin: 10px 15px 15px 0;}p.editorial-caption {	padding: 5px;}#content-panel .doc p.editorial-caption {	padding: 5px;	text-align:left;}#content-panel div.editorial-image {	margin-left:2%;	margin-top: 2px;}/*adding styles for Legalis Debut notifications - SG - 11.11.11 */#document-unavailable h1 {text-align:center;}#document-unavailable p {margin:5px 0;}/* CSS styling for Contul meu - SG. 30.05.2012 */span.profile-user-username-label, span.profile-user-company-label {	font-size:14px;	font-weight:bold;}.user-modules-first-column span.middle-bar-text {	font-weight:bold;}.user-modules-second-column span.middle-bar-text {	font-weight:bold;	color:#990000;}.bookmarks-folders-panel-title, .settings-panel-title , .change-password-panel-title{	font-size: 15px!important;	margin-bottom:10px!important;}/* Comparison of laws - changes in styling - 20.08.2012 - S. Gorgan */.new, .added a {  color: green;  text-decoration:underline;}.added {  color: green;  font-weight:bold;}/* Images in TOC */.toc-product-image {  margin: 0 5px 5px 0;}/* Icon in TOC*/.rich-tree-node-icon, .rich-tree-node-icon-leaf, .rich-tree-node-handleicon {  vertical-align:top;}#content-panel div.doc div.subtoc p.title {	text-align: center;}.footnote-content-header {	text-align: left;	font-weight: bold;	text-decoration: underline;}.footnote-content-number {	display: block;	float: left;	text-align: left;	font-weight: bold;}a.link-preview-link {	background: url("http://www.legalis.ro/img/preview-link.png") no-repeat scroll 0 0 transparent;    padding-left: 15px;}/* LEGALIS DEBUT STYLING */ #mainmenu a.simple-logout-guest-user {    background-color: #990000;    border-radius: 3px 3px 3px 3px;    color: #FFFFFF !important;    padding: 2px 5px !important;}.adds-placeholder {    margin-left: 8%;    margin-top: 5px;}    .notification {    background-color: #F1F1F1;    border: 1px solid #880000;    padding: 5px;}    #document-unavailable {    margin: 15px 2%;    text-align: justify;}
                    #f1 {    display:block;}h1 {	font-family: Georgia,Arial,sans-serif;	font-size:12px;}.only-print {    display: block;} 

                    @page {
                        size: 21cm 29.7 cmt;  /* A4 */
                        /*margin: 1cm 1cm 1cm 1cm; *//* Margins: 2.5 cm on each side */
                        mso-page-orientation: portrait;
                        mso-header: url("mydocument_files/headerfooter.htm") h1;
                        mso-footer: url("mydocument_files/headerfooter.htm") f1;
                    }

                    @page Section1 {
                    }

                    div.Section1 {
                        page: Section1;
                    }

                    p.MsoHeader, p.MsoFooter {
                        mso-pagination: widow-orphan;
                        tab-stops: center 216.0pt right 432.0pt;
                        font-size: 10pt;
                    }
                </style>
            <xml>
                <w:WordDocument>
                    <w:View>Print</w:View>
                    <w:Zoom>100</w:Zoom>
                    <w:DoNotOptimizeForBrowser></w:DoNotOptimizeForBrowser>
                </w:WordDocument>
            </xml>
        </head>
    <body>
    <div class="Section1">
    <div class="chapterview-print-content"><div class="doc"><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3qgj3da"><div class="frontpage"><div class="law-title"><div class="legislator"><p>PARLAMENTUL ROMÂNIEI <span class="chamber">CAMERA DEPUTAŢILOR</span> <span class="chamber">SENATUL</span> </p></div><p class="law-type"><span class="type">LEGEA</span> <span class="nr">Nr. 241</span>/<span class="year">2006</span></p><div class="title"><h2 class="title_line_2">serviciului de alimentare cu apă şi de canalizare nr. 241/2006<span class="footnote"><a title="Notă" href="#" onclick="displayFootnote('d5200261e63', 'Notă', 300)"><sup>*)</sup></a></span></h2></div><p class="mocit"><a href="document-view.seam?documentId=nvxv6mrqgezv6obv" multi-idref="MO_2013_85" class="" onclick="return validateLink('nvxv6mrqgezv6obv');">M.Of. nr. 85 din 8.2.2013</a></p></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3tmnqwsx3qgj3da"><div class="title"><div class="title"><h1 class="number"><em class="num">CAPITOLUL I</em></h1><h1 class="line-1">Dispoziţii generale</h1></div></div><div class="document-fragment articlenumber_1" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgfpxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bge" multi-idref="L_Parlamentul_241_2006-06-22_a1" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bge');">Art. 1</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Prezenta lege stabileşte cadrul juridic unitar privind înfiinţarea, organizarea, gestionarea, finanţarea, exploatarea, monitorizarea şi controlul furnizării/prestării reglementate a serviciului public de alimentare cu apă şi de canalizare al localităţilor.</p><p class="alineat"><em class="num">(2)</em> Dispoziţiile prezentei legi se aplică serviciului public de alimentare cu apă şi de canalizare organizat la nivelul comunelor, oraşelor, municipiilor, judeţelor sau, după caz, al asociaţiilor de dezvoltare intercomunitară cu obiect de activitate serviciul de alimentare cu apă şi de canalizare.</p><p class="alineat"><em class="num">(3)</em> Serviciul public de alimentare cu apă şi de canalizare face parte din sfera serviciilor comunitare de utilităţi publice, astfel cum acestea sunt definite de Legea serviciilor comunitare de utilităţi publice nr. 51/2006, cu modificările şi completările ulterioare. Serviciul public de alimentare cu apă şi de canalizare cuprinde totalitatea activităţilor reglementate prevăzute la <a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bge" multi-idref="L_Parlamentul_241_2006-06-22_a1" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bge');">art. 1 </a>alin. (2) lit. a), b) şi c) din<a href="document-view.seam?documentId=nr4f6njrl4zdambw" multi-idref="LX_51_2006" class="" onclick="return validateLink('nr4f6njrl4zdambw');"> Legea nr. 51/2006,</a> cu modificările şi completările ulterioare, prin care se asigură satisfacerea nevoilor de utilitate şi interes public general ale colectivităţilor locale.</p></div></div></div><div class="document-fragment articlenumber_2" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgjpxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgi" multi-idref="L_Parlamentul_241_2006-06-22_a2" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgi');">Art. 2</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Serviciul public de alimentare cu apă şi de canalizare, denumit în continuare <em class="italic">serviciul de alimentare cu apă şi de canalizare,</em> se înfiinţează, se organizează şi se gestionează sub conducerea, coordonarea, controlul şi responsabilitatea autorităţilor administraţiei publice locale şi are drept scop alimentarea cu apă, canalizarea şi epurarea apelor uzate pentru toţi utilizatorii de pe teritoriul localităţilor.</p><p class="alineat"><em class="num">(2)</em> Serviciul de alimentare cu apă şi de canalizare se furnizează/prestează prin exploatarea unei infrastructuri tehnico-edilitare specifice, denumită <em class="italic">sistem public de alimentare cu apă şi de canalizare.</em></p><p class="alineat"><em class="num">(3)</em> Sistemele publice de alimentare cu apă şi de canalizare a apelor uzate, denumite în continuare <em class="italic">sisteme de alimentare cu apă şi de canalizare,</em> constituie ansambluri tehnologice şi funcţionale integrate care acoperă întregul circuit tehnologic, de la captarea din sursă a apei brute până la evacuarea în emisari a apelor uzate epurate.</p><p class="alineat"><em class="num">(4)</em> În localităţile rurale se poate organiza, după caz, numai serviciul de alimentare cu apă, cu condiţia asigurării colectării apelor uzate prin alte sisteme individuale.</p></div></div></div><div class="document-fragment articlenumber_3" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgnpxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgm" multi-idref="L_Parlamentul_241_2006-06-22_a3" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgm');">Art. 3</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>Termenii tehnici utilizaţi în cuprinsul prezentei legi se definesc după cum urmează:</p><p class="litera"><em class="num">a)</em><em class="italic">serviciu de alimentare cu apă şi de canalizare</em> – totalitatea activităţilor de utilitate publică şi de interes economic şi social general efectuate în scopul captării, tratării, transportului, înmagazinării şi distribuirii apei potabile sau industriale tuturor utilizatorilor de pe teritoriul unei localităţi, respectiv pentru colectarea, transportul, epurarea şi evacuarea apelor uzate, a apelor meteorice şi a apelor de suprafaţă provenite din intravilanul acesteia;</p><p class="litera"><em class="num">b)</em><em class="italic">serviciu de alimentare cu apă</em> – totalitatea activităţilor necesare pentru:</p><p class="liniuta"> – captarea apei brute, din surse de suprafaţă sau subterane;</p><p class="liniuta"> – tratarea apei brute;</p><p class="liniuta"> – transportul apei potabile şi/sau industriale;</p><p class="liniuta"> – înmagazinarea apei;</p><p class="liniuta"> – distribuţia apei potabile şi/sau industriale;</p><p class="litera"><em class="num">c)</em><em class="italic">serviciul de canalizare</em> – totalitatea activităţilor necesare pentru:</p><p class="liniuta"> – colectarea, transportul şi evacuarea apelor uzate de la utilizatori la staţiile de epurare;</p><p class="liniuta"> – epurarea apelor uzate şi evacuarea apei epurate în emisar;</p><p class="liniuta"> – colectarea, evacuarea şi tratarea adecvată a deşeurilor din gurile de scurgere a apelor pluviale şi asigurarea funcţionalităţii acestora;</p><p class="liniuta"> – evacuarea, tratarea şi depozitarea nămolurilor şi a altor deşeuri similare derivate din activităţile prevăzute mai sus;</p><p class="liniuta"> – evacuarea apelor pluviale şi de suprafaţă din intravilanul localităţilor;</p><p class="litera"><em class="num">d)</em><em class="italic">sistem public de alimentare cu apă</em> – ansamblul construcţiilor şi terenurilor, instalaţiilor tehnologice, echipamentelor funcţionale şi dotărilor specifice, prin care se realizează serviciul public de alimentare cu apă. Sistemele publice de alimentare cu apă cuprind, de regulă, următoarele componente:</p><p class="liniuta"> – captări;</p><p class="liniuta"> – aducţiuni;</p><p class="liniuta"> – staţii de tratare;</p><p class="liniuta"> – staţii de pompare cu sau fără hidrofor;</p><p class="liniuta"> – rezervoare de înmagazinare;</p><p class="liniuta"> – reţele de transport şi distribuţie;</p><p class="liniuta"> – branşamente, până la punctul de delimitare;</p><p class="litera"><em class="num">e)</em><em class="italic">sistem public de canalizare</em> – ansamblul construcţiilor şi terenurilor aferente instalaţiilor tehnologice, echipamentelor funcţionale şi dotărilor specifice, prin care se realizează serviciul public de canalizare. Sistemele publice de canalizare cuprind, de regulă, următoarele componente:</p><p class="liniuta"> – racorduri de canalizare de la punctul de delimitare şi preluare;</p><p class="liniuta"> – reţele de canalizare;</p><p class="liniuta"> – staţii de pompare;</p><p class="liniuta"> – staţii de epurare;</p><p class="liniuta"> – colectoare de evacuare spre emisar;</p><p class="liniuta"> – guri de vărsare în emisar;</p><p class="liniuta"> – depozite de nămol deshidratat;</p><p class="litera"><em class="num">f)</em><em class="italic">reţea publică de transport al apei</em> – parte a sistemului public de alimentare cu apă alcătuită din reţeaua de conducte cuprinsă între captare şi reţeaua de distribuţie;</p><p class="litera"><em class="num">g)</em><em class="italic">reţea publică de distribuţie a apei</em> – parte a sistemului public de alimentare cu apă, alcătuită din reţeaua de conducte, armături şi construcţii-anexe, care asigură distribuţia apei la 2 sau la mai mulţi utilizatori independenţi;</p><p class="litera"><em class="num">h)</em><em class="italic">reţea publică de canalizare</em> – parte a sistemului public de canalizare, alcătuită din canale colectoare, cămine, guri de scurgere şi construcţii-anexe care asigură preluarea, evacuarea şi transportul apelor de canalizare de la 2 sau de la mai mulţi utilizatori independenţi.</p><p>Nu constituie reţele publice:</p><p class="liniuta"> – reţelele interioare de utilizare aferente unei clădiri de locuit cu mai multe apartamente, chiar dacă aceasta este în proprietatea mai multor persoane fizice sau juridice;</p><p class="liniuta"> – reţelele aferente unei incinte proprietate privată sau unei instituţii publice pe care se află mai multe imobile, indiferent de destinaţie, despărţite de zone verzi şi alei interioare private;</p><p class="liniuta"> – reţelele aferente unei platforme industriale, în care drumurile de acces şi spaţiile verzi sunt proprietate privată, chiar dacă aceasta este administrată de mai multe persoane juridice;</p><p class="litera"><em class="num">i)</em><em class="italic">branşament de apă</em> – partea din reţeaua publică de alimentare cu apă care asigură legătura dintre reţeaua publică de distribuţie şi reţeaua interioară a unei incinte sau a unei clădiri. Branşamentul deserveşte un singur utilizator. În cazuri bine justificate şi atunci când condiţiile tehnice nu permit altă soluţie se poate admite alimentarea mai multor utilizatori prin acelaşi branşament. Părţile componente ale unui branşament se precizează în regulamentul-cadru al serviciului de alimentare cu apă şi de canalizare. Branşamentul, până la contor, inclusiv căminul de branşament şi contorul, aparţin reţelei publice de distribuţie, indiferent de modul de finanţare a execuţiei. Finanţarea execuţiei branşamentului se asigură de operator, respectiv de utilizator, corespunzător punctului de delimitare a instalaţiilor. Amplasamentul căminului de branşament se stabileşte la punctul de delimitare al instalaţiilor, de regulă la limita de proprietate a utilizatorului, cu respectarea regimului juridic al proprietăţii şi numai în baza unei documentaţii avizate de operator. În cazul condominiilor existente, separarea şi individualizarea consumurilor la nivel de proprietate/apartament individual se fac prin montarea repartitoarelor de costuri. Cheltuielile aferente individualizării consumurilor sunt suportate de coproprietarii condominiului, operatorul având numai obligaţia montării contorului principal de branşament la nivelul limitei de proprietate;</p><p class="litera"><em class="num">j)</em><em class="italic">repartitor de costuri</em> – aparat utilizat în imobilele condominiale dotate cu instalaţii interioare de utilizare comune, în scopul individualizării consumurilor şi repartizării pe proprietăţi/apartamente individuale a costurilor aferente consumului total de apă înregistrat la nivelul branşamentului imobilului;</p><p class="litera"><em class="num">k)</em><em class="italic">repartizarea costurilor</em>– totalitatea acţiunilor desfăşurate, conform reglementărilor legale în vigoare, de către o persoană fizică sau persoană juridică în scopul repartizării pe proprietăţi/apartamente individuale a costurilor aferente consumului de apă în imobilele condominiale dotate cu instalaţii interioare de utilizare comune;</p><p class="litera"><em class="num">l)</em><em class="italic">racord de canalizare</em> – partea din reţeaua publică de canalizare care asigură legătura dintre instalaţiile interioare de canalizare ale utilizatorului şi reţeaua publică de canalizare, inclusiv căminul de racord; părţile componente ale unui racord se precizează în regulamentul-cadru de organizare şi funcţionare a serviciilor de alimentare cu apă şi de canalizare. Racordul de la cămin spre reţea, inclusiv căminul de racord, aparţine reţelei publice de canalizare;</p><p class="litera"><em class="num">m)</em><em class="italic">aviz de branşare/racordare</em> – documentul scris, emis de operatorul serviciului de alimentare cu apă şi de canalizare, prin care se stabilesc condiţiile tehnice cu privire la proiectarea, amplasarea şi execuţia branşamentelor de apă, respectiv a racordurilor de canalizare şi prin care se stabileşte punctul de delimitare dintre reţelele publice şi instalaţiile de utilizare;</p><p class="litera"><em class="num">n)</em><em class="italic">acord de furnizare</em> – documentul scris, emis de operator, care stabileşte condiţiile de furnizare pentru utilizator şi defineşte parametrii cantitativi şi calitativi ai serviciului la branşamentul utilizatorului şi prin care operatorul se angajează să furnizeze serviciul de alimentare cu apă;</p><p class="litera"><em class="num">o)</em><em class="italic">acord de preluare</em> – documentul scris, emis de operatorul serviciului de canalizare pentru utilizator, prin care acesta se angajează să presteze serviciul de canalizare şi care defineşte condiţiile şi parametrii cantitativi şi calitativi ai apelor uzate menajere şi/sau industriale preluate la canalizarea publică;</p><p class="litera"><em class="num">p)</em><em class="italic">ape uzate menajere</em> – apele de canalizare rezultate din folosirea apei în gospodării, instituţii publice şi servicii, care rezultă mai ales din metabolismul uman şi din activităţi menajere şi igienico-sanitare;</p><p class="litera"><em class="num">q)</em><em class="italic">ape uzate industriale</em> – apele de canalizare rezultate din activităţi economico-industriale sau corespunzând unei alte utilizări a apei decât cea menajeră;</p><p class="litera"><em class="num">r)</em><em class="italic">ape uzate orăşeneşti</em> – apele de canalizare rezultate din amestecul apelor uzate menajere cu apele uzate industriale sau agrozootehnice, preepurate sau nu, precum şi apele care provin din stropirea şi spălarea drumurilor publice sau private, a aleilor, a grădinilor şi a curţilor imobilelor;</p><p class="litera"><em class="num">s)</em><em class="italic">ape pluviale</em> – apele de canalizare care provin din precipitaţii atmosferice;</p><p class="litera"><em class="num">ş)</em><em class="italic">instalaţii interioare de apă</em> – totalitatea instalaţiilor aflate în proprietatea sau în administrarea utilizatorului, amplasate după punctul de delimitare dintre reţeaua publică şi instalaţia interioară de utilizare a apei, şi care asigură transportul apei preluate din reţeaua publică la punctele de consum şi/sau la instalaţiile de utilizare;</p><p class="litera"><em class="num">t)</em><em class="italic">instalaţii interioare de canalizare</em> – totalitatea instalaţiilor aflate în proprietatea sau în administrarea utilizatorului, care asigură preluarea şi transportul apei uzate de la instalaţiile de utilizare a apei până la căminul de racord din reţeaua publică;</p><p class="litera"><em class="num">ţ)</em><em class="italic">punct de delimitare</em> – locul în care instalaţiile aflate în proprietatea sau în administrarea utilizatorului se branşează la instalaţiile aflate în administrarea operatorului furnizor/prestator de servicii, respectiv locul unde se realizează efectiv furnizarea/prestarea serviciului către utilizator. Punctul de delimitare a instalaţiilor asigură identificarea amplasamentului căminului de branşament, precizează poziţia de montare a dispozitivelor de măsurare-înregistrare a consumurilor, permite stabilirea apartenenţei instalaţiilor, precum şi precizarea drepturilor, respectiv a obligaţiilor ce revin părţilor cu privire la furnizarea/prestarea serviciului, respectiv la exploatarea, întreţinerea şi repararea instalaţiilor. Delimitarea dintre instalaţiile interioare de canalizare şi reţeaua publică de canalizare se face prin/la căminul de racord, care este prima componentă a reţelei publice de canalizare, în sensul de curgere a apei uzate;</p><p class="litera"><em class="num">u)</em><em class="italic">contor de branşament</em> – aparatul de măsurare a volumului de apă consumat de utilizator, care se montează pe branşament între două vane – robinete la limita proprietăţii utilizatorului; contorul este ultima componentă a reţelei publice de distribuţie în sensul de curgere a apei;</p><p class="litera"><em class="num">v)</em><em class="italic">asociaţie de dezvoltare intercomunitară cu obiect de activitate serviciul de alimentare cu apă şi de canalizare</em> – asociaţia de dezvoltare intercomunitară cu obiect de activitate serviciile de utilităţi publice, astfel cum este definită de<a href="document-view.seam?documentId=nr4f6njrl4zdambw" multi-idref="LX_51_2006" class="" onclick="return validateLink('nr4f6njrl4zdambw');"> Legea nr. 51/2006,</a> cu modificările şi completările ulterioare, constituită în scopul înfiinţării, organizării, finanţării, exploatării, monitorizării şi controlului furnizării/prestării serviciului de alimentare cu apă şi de canalizare, inclusiv pentru crearea, modernizarea şi/sau dezvoltarea sistemelor publice de alimentare cu apă şi de canalizare.</p></div></div></div><div class="document-fragment articlenumber_4" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgrpxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgq" multi-idref="L_Parlamentul_241_2006-06-22_a4" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgq');">Art. 4</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Apa potabilă distribuită prin sistemele de alimentare cu apă este destinată satisfacerii cu prioritate a nevoilor gospodăreşti ale populaţiei, ale instituţiilor publice, ale operatorilor economici şi, după caz, pentru combaterea şi stingerea incendiilor, în lipsa apei industriale.</p><p class="alineat"><em class="num">(2)</em> Apa potabilă distribuită utilizatorilor trebuie să îndeplinească, la branşamentele acestora, condiţiile de potabilitate prevăzute în normele tehnice şi reglementările legale în vigoare, precum şi parametrii de debit şi presiune precizaţi în acordurile şi contractele de furnizare.</p><p class="alineat"><em class="num">(3)</em> Bunurile aferente infrastructurii tehnico-edilitare aparţinând sistemului de alimentare cu apă şi de canalizare realizate prin investiţii noi de către o unitate administrativ-teritorială pe raza unei alte unităţi administrativ-teritoriale aparţin domeniului public al unităţii administrativ-teritoriale pe care o deservesc.</p><p class="alineat"><em class="num">(4)</em> Utilizarea apei potabile în alte scopuri decât cele menţionate la alin. (1) este permisă numai în măsura în care există disponibilităţi faţă de necesarul de apă potabilă al localităţilor, stabilit potrivit prescripţiilor tehnice în vigoare.</p><p class="alineat"><em class="num">(5)</em> În cazul în care cerinţele de apă potabilă ale operatorilor economici nu pot fi acoperite integral sau pot fi acoperite numai parţial, aceştia pot să îşi asigure alimentarea cu apă potabilă prin sisteme proprii, realizate şi exploatate în condiţiile legii.</p><p class="alineat"><em class="num">(6)</em> Pentru satisfacerea altor nevoi, cum ar fi stropitul străzilor şi al spaţiilor verzi, spălatul pieţelor şi al străzilor, spălarea periodică a sistemului de canalizare, spălarea autovehiculelor şi consumul tehnologic al unităţilor industriale, se va utiliza cu precădere apă industrială.</p><p class="alineat"><em class="num">(7)</em> Apa industrială sau cu caracter nepotabil se poate asigura fie prin sisteme publice de alimentare cu apă industrială, fie prin sisteme individuale realizate şi exploatate de operatorii economici.</p><p class="alineat"><em class="num">(8)</em> Se interzice orice legătură sau interconectare între sistemele de alimentare cu apă potabilă şi sistemele de alimentare cu apă industrială.</p></div></div></div><div class="document-fragment articlenumber_5" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgvpxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgu" multi-idref="L_Parlamentul_241_2006-06-22_a5" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgu');">Art. 5</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Sistemul de canalizare trebuie să asigure cu precădere colectarea, transportul, epurarea şi evacuarea într-un receptor natural a apelor uzate provenite de la utilizatorii serviciului de alimentare cu apă, precum şi a apelor pluviale sau de suprafaţă colectate de pe teritoriul localităţilor.</p><p class="alineat"><em class="num">(2)</em> Nămolurile provenite din staţiile de tratare a apei, din sistemele de canalizare şi din staţiile de epurare a apelor uzate orăşeneşti se tratează şi se prelucrează în vederea neutralizării, deshidratării, depozitării controlate sau valorificării, potrivit reglementărilor legale în vigoare privind protecţia şi conservarea mediului, respectiv igiena şi sănătatea populaţiei.</p><p class="alineat"><em class="num">(3)</em> Apele uzate evacuate în sistemele de canalizare trebuie să respecte condiţiile precizate prin acordul de preluare în canalizarea publică, respectiv prin contractul de prestare a serviciului, precum şi pe cele impuse prin reglementările tehnice în vigoare, astfel încât prin natura, cantitatea ori calitatea lor să nu conducă la:</p><p class="litera"><em class="num">a)</em> degradarea construcţiilor şi instalaţiilor componente ale sistemelor de canalizare;</p><p class="litera"><em class="num">b)</em> diminuarea capacităţii de transport a reţelelor şi a canalelor colectoare;</p><p class="litera"><em class="num">c)</em> perturbarea funcţionării normale a staţiei de epurare, prin depăşirea debitului şi a încărcării sau prin inhibarea proceselor de epurare;</p><p class="litera"><em class="num">d)</em> apariţia unor pericole pentru igiena şi sănătatea populaţiei sau a personalului de exploatare a sistemului;</p><p class="litera"><em class="num">e)</em> apariţia pericolelor de explozie.</p><p class="alineat"><em class="num">(4)</em> Evacuarea în receptorii naturali a apelor uzate epurate şi depozitarea nămolurilor provenite din staţiile de epurare se fac numai în condiţiile calitative şi cantitative precizate în avizele, acordurile şi autorizaţiile de mediu eliberate de autorităţile competente, potrivit reglementărilor în vigoare din domeniul protecţiei calităţii apei şi a mediului, astfel încât să se garanteze protecţia şi conservarea mediului, respectiv igiena şi sănătatea populaţiei.</p><p class="alineat"><em class="num">(5)</em> Preluarea în sistemele de canalizare a apelor uzate provenite de la operatori economici industriali sau de la alţi utilizatori neracordaţi la reţelele publice de distribuţie a apei se poate aproba numai în măsura în care capacitatea sistemelor nu este depăşită din punct de vedere hidraulic sau al încărcării cu substanţe impurificatoare şi numai dacă nu conţin poluanţi toxici sau care pot inhiba ori bloca procesul de epurare.</p></div></div></div><div class="document-fragment articlenumber_6" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgzpxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgy" multi-idref="L_Parlamentul_241_2006-06-22_a6" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgy');">Art. 6</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>Desfăşurarea activităţilor specifice serviciului de alimentare cu apă şi de canalizare, indiferent de forma de gestiune aleasă, se realizează pe baza unui regulament al serviciului şi a unui caiet de sarcini, elaborate şi aprobate de autorităţile administraţiei publice locale sau, după caz, de asociaţiile de dezvoltare intercomunitară cu obiect de activitate serviciul de alimentare cu apă şi de canalizare, în conformitate cu regulamentul-cadru, respectiv cu caietul de sarcini-cadru al serviciului de alimentare cu apă şi de canalizare, elaborate de Autoritatea Naţională de Reglementare pentru Serviciile Comunitare de Utilităţi Publice, denumită în continuare <em class="italic">A.N.R.S.C.,</em> şi aprobate prin ordin<span class="footnote"><a title="Notă" href="#" onclick="displayFootnote('d5200261e775', 'Notă', 300)"><sup>*)</sup></a></span> al preşedintelui acesteia. În cazul asociaţiilor de dezvoltare intercomunitară cu obiect de activitate serviciul de alimentare cu apă şi de canalizare, regulamentul serviciului şi caietul de sarcini se elaborează în cadrul acestora, se avizează de autorităţile deliberative ale unităţilor administrativ-teritoriale membre şi se aprobă de adunările generale.</p></div></div></div><div class="document-fragment articlenumber_7" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bg5pxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bg4" multi-idref="L_Parlamentul_241_2006-06-22_a7" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bg4');">Art. 7</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Serviciul de alimentare cu apă şi de canalizare se înfiinţează, se organizează şi funcţionează pe baza următoarelor principii:</p><p class="litera"><em class="num">a)</em> securitatea serviciului;</p><p class="litera"><em class="num">b)</em> tarifarea echitabilă;</p><p class="litera"><em class="num">c)</em> rentabilitatea, calitatea şi eficienţa serviciului;</p><p class="litera"><em class="num">d)</em> transparenţa şi responsabilitatea publică, incluzând consultarea cu patronatele, sindicatele, utilizatorii şi cu asociaţiile reprezentative ale acestora;</p><p class="litera"><em class="num">e)</em> continuitatea din punct de vedere cantitativ şi calitativ;</p><p class="litera"><em class="num">f)</em> adaptabilitatea la cerinţele utilizatorilor;</p><p class="litera"><em class="num">g)</em> accesibilitatea egală a utilizatorilor la serviciul public, pe baze contractuale;</p><p class="litera"><em class="num">h)</em> respectarea reglementărilor specifice din domeniul gospodăririi apelor, protecţiei mediului şi sănătăţii populaţiei.</p><p class="alineat"><em class="num">(2)</em> Principiile prevăzute la alin. (1) vor fi în mod obligatoriu cuprinse şi dezvoltate atât în regulamentul-cadru al serviciului de alimentare cu apă şi de canalizare, cât şi în regulamentele serviciilor de alimentare cu apă şi de canalizare aprobate la nivel local.</p></div></div></div><div class="document-fragment articlenumber_8" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bhbpxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bha" multi-idref="L_Parlamentul_241_2006-06-22_a8" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bha');">Art. 8</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Serviciul furnizat/prestat prin sistemele de alimentare cu apă şi de canalizare trebuie să îndeplinească, la nivelul utilizatorilor, indicatorii de performanţă prevăzuţi în regulamentul serviciului de alimentare cu apă şi de canalizare.</p><p class="alineat"><em class="num">(2)</em> Indicatorii de performanţă ai serviciului furnizat/prestat utilizatorilor se stabilesc pe baza unui studiu de specialitate întocmit de autorităţile administraţiei publice locale sau, după caz, de asociaţiile de dezvoltare intercomunitară cu obiect de activitate serviciul de alimentare cu apă şi de canalizare, în funcţie de necesităţile utilizatorilor, de starea tehnică a sistemelor de alimentare cu apă şi de canalizare şi de eficienţa acestora, cu respectarea indicatorilor de performanţă minimali prevăzuţi în regulamentul-cadru, respectiv în caietul de sarcini-cadru al serviciului de alimentare cu apă şi de canalizare. În cazul asociaţiilor de dezvoltare intercomunitară cu obiect de activitate serviciul de alimentare cu apă şi de canalizare, studiul de specialitate se elaborează în cadrul acestora, se avizează de autorităţile deliberative ale unităţilor administrativ-teritoriale membre şi se aprobă de adunările generale.</p><p class="alineat"><em class="num">(3)</em> Propunerile de indicatori de performanţă ai serviciului de alimentare cu apă şi de canalizare furnizat/prestat utilizatorilor, rezultate din studiul de specialitate efectuat în acest scop, vor fi supuse dezbaterii publice înaintea aprobării lor de către autorităţile administraţiei publice locale.</p></div></div></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3tmnqws2k7oazhmma"><div class="title"><div class="title"><h1 class="number"><em class="num">CAPITOLUL II</em></h1><h1 class="line-1">Autorităţi şi competenţe</h1></div></div><div class="document-fragment articlenumber_9" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bhfpxamtwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bhe" multi-idref="L_Parlamentul_241_2006-06-22_a9" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bhe');">Art. 9</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Statul sprijină prin măsuri legislative, administrative şi economice dezvoltarea durabilă a serviciului de alimentare cu apă şi de canalizare, precum şi a sistemelor de alimentare cu apă şi de canalizare aferente.</p><p class="alineat"><em class="num">(2)</em> Măsurile adoptate la nivelul autorităţilor administraţiei publice centrale competente trebuie să conducă la atingerea următoarelor obiective strategice:</p><p class="litera"><em class="num">a)</em> dezvoltarea şi extinderea serviciului de alimentare cu apă şi de canalizare la nivelul întregii ţări, în scopul îmbunătăţirii condiţiilor de viaţă ale comunităţilor locale;</p><p class="litera"><em class="num">b)</em> realizarea unui serviciu şi a unei infrastructuri tehnico-edilitare moderne, capabile să susţină dezvoltarea economico-socială a localităţilor, să atragă investiţii private şi să stimuleze dezvoltarea durabilă a comunităţilor locale;</p><p class="litera"><em class="num">c)</em> conservarea şi protecţia mediului şi a sănătăţii publice.</p></div></div></div><div class="document-fragment articlenumber_10" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgeyf64bsoyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgeya" multi-idref="L_Parlamentul_241_2006-06-22_a10" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgeya');">Art. 10</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Autorităţile deliberative ale unităţilor administrativ-teritoriale au competenţă exclusivă, ce poate fi exercitată şi prin intermediul asociaţiilor de dezvoltare intercomunitară cu obiect de activitate serviciul de alimentare cu apă şi de canalizare, în condiţiile<a href="document-view.seam?documentId=nr4f6njrl4zdambw" multi-idref="LX_51_2006" class="" onclick="return validateLink('nr4f6njrl4zdambw');"> Legii nr. 51/2006,</a> cu modificările şi completările ulterioare, în numele şi pe seama unităţilor administrativ-teritoriale asociate, în baza mandatului acordat acestora, în tot ceea ce priveşte:</p><p class="litera"><em class="num">a)</em> aprobarea strategiilor locale de înfiinţare, organizare, gestiune şi funcţionare a serviciului de alimentare cu apă şi de canalizare;</p><p class="litera"><em class="num">b)</em> aprobarea programelor de investiţii privind înfiinţarea, dezvoltarea, modernizarea şi reabilitarea infrastructurii tehnico-edilitare aferente serviciului;</p><p class="litera"><em class="num">c)</em> aprobarea regulamentelor şi a caietelor de sarcini ale serviciului;</p><p class="litera"><em class="num">d)</em> adoptarea modalităţii de gestiune şi aprobarea documentaţiilor de organizare şi derulare a procedurilor de delegare a gestiunii;</p><p class="litera"><em class="num">e)</em> aprobarea indicatorilor de performanţă ai serviciului.</p><p class="alineat"><em class="num">(2)</em> Unităţile administrativ-teritoriale se pot asocia între ele în vederea înfiinţării, organizării, finanţării, monitorizării şi gestionării în interes comun a serviciului de alimentare cu apă şi de canalizare şi pentru înfiinţarea, modernizarea, dezvoltarea şi exploatarea infrastructurii tehnico-edilitare aferente acestuia, în condiţiile stabilite prin<a href="document-view.seam?documentId=nr4f6njrl4zdambw" multi-idref="LX_51_2006" class="" onclick="return validateLink('nr4f6njrl4zdambw');"> Legea nr. 51/2006,</a> cu modificările şi completările ulterioare.</p></div></div></div><div class="document-fragment articlenumber_11" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgeyv64bsoyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3c2mbwfuzdex3bgeyq" multi-idref="L_Parlamentul_241_2006-06-22_a11" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgqyv6mrqga3