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_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3qgf3da"><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. 230</span>/<span class="year">2006</span></p><div class="title"><h2 class="title_line_2">serviciului de iluminat public</h2></div><p class="mocit"><a href="document-view.seam?documentId=nvxv6mrqga3f6njrg4" multi-idref="MO_2006_517" class="" onclick="return validateLink('nvxv6mrqga3f6njrg4');">M.Of. nr. 517 din 15.6.2006</a></p></div></div><div class="legal_text"><div class="legal_text"><p><em class="emitent">Parlamentul României</em> adoptă prezenta lege.</p></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3tmnqwsx3qgf3da"><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_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgfpxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge" multi-idref="L_Parlamentul_230_2006-06-07_a1" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge');">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 şi instituţional unitar privind înfiinţarea, organizarea, exploatarea, gestionarea, finanţarea, monitorizarea şi controlul funcţionării serviciului de iluminat public în comune, oraşe şi municipii.</p><p class="alineat"><em class="num">(2)</em> Serviciul de iluminat public face parte din sfera serviciilor comunitare de utilităţi publice şi cuprinde totalitatea acţiunilor şi activităţilor de utilitate publică şi de interes economic şi social general desfăşurate la nivelul unităţilor administrativ-teritoriale sub conducerea, coordonarea şi responsabilitatea autorităţilor administraţiei publice locale, în scopul asigurării iluminatului public.</p><p class="alineat"><em class="num">(3)</em> Serviciul de iluminat public cuprinde iluminatul stradal-rutier, iluminatul stradal-pietonal, iluminatul arhitectural, iluminatul ornamental şi iluminatul ornamental-festiv al comunelor, oraşelor şi municipiilor.</p></div></div></div><div class="document-fragment articlenumber_2" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgjpxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgi" multi-idref="L_Parlamentul_230_2006-06-07_a2" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgi');">Art. 2</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Serviciul de iluminat public se realizează prin intermediul unui ansamblu tehnologic şi funcţional, alcătuit din construcţii, instalaţii şi echipamente specifice, denumit în continuare <em class="italic">sistem de iluminat public.</em></p><p class="alineat"><em class="num">(2)</em> În înţelesul prezentei legi, sistemul de iluminat public este ansamblul format din puncte de aprindere, cutii de distribuţie, cutii de trecere, linii electrice de joasă tensiune subterane sau aeriene, fundaţii, stâlpi, instalaţii de legare la pământ, console, corpuri de iluminat, accesorii, conductoare, izolatoare, cleme, armături, echipamente de comandă, automatizare şi măsurare utilizate pentru iluminatul public.</p><p class="alineat"><em class="num">(3)</em> În cazul sistemelor de iluminat public destinate exclusiv serviciului de iluminat public, părţile componente ale acestora sunt cele prevăzute la alin. (2).</p><p class="alineat"><em class="num">(4)</em> În cazul în care serviciul de iluminat public se realizează utilizând elemente ale sistemului de distribuţie a energiei electrice, sistemul de iluminat cuprinde elementele prevăzute la alin. (2), cu excepţia elementelor care fac parte din sistemul de distribuţie a energiei electrice, astfel cum este definit prin prezenta lege.</p></div></div></div><div class="document-fragment articlenumber_3" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgnpxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgm" multi-idref="L_Parlamentul_230_2006-06-07_a3" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgm');">Art. 3</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>Termenii utilizaţi în cuprinsul prezentei legi se definesc după cum urmează:</p><p class="litera"><em class="num">a)</em><em class="italic">autorităţi de reglementare competente</em> – 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 Autoritatea Naţională de Reglementare în Domeniul Energiei, denumită în continuare <em class="italic">A.N.R.E.;</em></p><p class="litera"><em class="num">b)</em><em class="italic">dispozitiv (corp) de iluminat</em> – aparatul de iluminat care serveşte la distribuţia, filtrarea sau transmisia luminii produse de la una sau mai multe lămpi către exterior;</p><p class="litera"><em class="num">c)</em><em class="italic">iluminat arhitectural</em> – iluminatul destinat punerii în evidenţă a unor monumente de artă sau istorice ori a unor obiective de importanţă publică sau culturală pentru comunitatea locală;</p><p class="litera"><em class="num">d)</em><em class="italic">iluminat ornamental</em> – iluminatul zonelor destinate parcurilor, spaţiilor de agrement, pieţelor, târgurilor şi altora asemenea;</p><p class="litera"><em class="num">e)</em><em class="italic">iluminat ornamental-festiv</em> – iluminatul temporar utilizat cu ocazia sărbătorilor şi altor evenimente festive;</p><p class="litera"><em class="num">f)</em><em class="italic">iluminat stradal-pietonal</em> – iluminatul căilor de acces pietonal;</p><p class="litera"><em class="num">g)</em><em class="italic">iluminat stradal-rutier</em> – iluminatul căilor de circulaţie rutieră;</p><p class="litera"><em class="num">h)</em><em class="italic">licenţă</em> – actul tehnic şi juridic emis de A.N.R.S.C., prin care se recunoaşte calitatea de operator al serviciului de iluminat public, precum şi capacitatea şi dreptul de a presta acest serviciu;</p><p class="litera"><em class="num">i)</em><em class="italic">punct de delimitare în cazul sistemelor folosite exclusiv pentru iluminatul public</em> – punctul de separare între sistemul de distribuţie a energiei electrice şi sistemul de iluminat public, care se stabileşte la punctul de racord al cablurilor de plecare din tablourile şi cutiile de distribuţie;</p><p class="litera"><em class="num">j)</em><em class="italic">punct de delimitare în cazul sistemelor folosite atât pentru iluminatul public, cât şi pentru distribuţia energiei electrice</em> – punctul de separare între sistemul de distribuţie a energiei electrice şi sistemul de iluminat public care se stabileşte la clemele de racord ale coloanelor de alimentare a corpurilor de iluminat public;</p><p class="litera"><em class="num">k)</em><em class="italic">sistem de distribuţie a energiei electrice</em> – totalitatea instalaţiilor deţinute de un operator de distribuţie care cuprinde ansamblul de linii, inclusiv elemente de susţinere şi de protecţie ale acestora, staţii electrice, posturi de transformare şi alte echipamente electroenergetice conectate între ele, cu tensiunea de linie nominală până la 110 kV inclusiv, destinate transmiterii energiei electrice de la reţelele electrice de transport sau de la producători către instalaţiile proprii ale consumatorilor de energie electrică;</p><p class="litera"><em class="num">l)</em><em class="italic">sistem de iluminat public</em> – ansamblul format din puncte de aprindere, cutii de distribuţie, cutii de trecere, linii electrice de joasă tensiune subterane sau aeriene, fundaţii, elemente de susţinere a liniilor, instalaţii de legare la pământ, console, corpuri de iluminat, accesorii, conductoare, izolatoare, cleme, armături, echipamente de comandă, automatizare şi măsurare utilizate pentru iluminatul public.</p></div></div></div><div class="document-fragment articlenumber_4" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgrpxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgq" multi-idref="L_Parlamentul_230_2006-06-07_a4" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgq');">Art. 4</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Sistemul de iluminat public destinat exclusiv prestării serviciului de iluminat public este parte componentă a infrastructurii tehnico-edilitare a unităţilor administrativ-teritoriale care, în conformitate cu Legea serviciilor comunitare de utilităţi publice nr. 51/2006, publicată în <a href="document-view.seam?documentId=nvxv6mrqga3f6mrvgq" multi-idref="MO_2006_254" class="" onclick="return validateLink('nvxv6mrqga3f6mrvgq');">Monitorul Oficial al României, Partea I, nr. 254 din 12 martie 2006</a>, aparţin proprietăţii publice a acestora şi se evidenţiază şi se inventariază în cadastrele imobiliar-edilitare ale unităţilor administrativ-teritoriale.</p><p class="alineat"><em class="num">(2)</em> În situaţia în care sistemul de iluminat public se încadrează în prevederile <a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgi" multi-idref="L_Parlamentul_230_2006-06-07_a2" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgi');">art. 2 </a>alin. (4), autorităţile administraţiei publice locale au drept de folosinţă cu titlu gratuit asupra infrastructurii sistemului de distribuţie a energiei electrice, pe toată durata existenţei acesteia, pe baza unui contract încheiat între autorităţile administraţiei publice locale şi proprietarul sistemului de distribuţie a energiei electrice. Prin acest contract se reglementează toate aspectele cu privire la asigurarea condiţiilor pentru prestarea serviciului de iluminat public, cu respectarea echitabilă a drepturilor şi obligaţiilor tuturor părţilor implicate.</p><p class="alineat"><em class="num">(3)</em> Contractul prevăzut la alin. (2) se încheie în baza contractului-cadru emis prin ordin comun al preşedinţilor A.N.R.E. şi A.N.R.S.C.</p><p class="alineat"><em class="num">(4)</em> În cazul în care autorităţile administraţiei publice locale vor să dezvolte serviciul de iluminat public utilizând infrastructura sistemului de distribuţie a energiei electrice existent, proprietarul sistemului de distribuţie a energiei electrice este obligat să accepte utilizarea solicitată, în conformitate cu prevederile contractului-cadru.</p><p class="alineat"><em class="num">(5)</em> În cazul prevăzut la <a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgi" multi-idref="L_Parlamentul_230_2006-06-07_a2" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgi');">art. 2 </a>alin. (4), refuzul proprietarilor sistemului de distribuţie a energiei electrice de a încheia contractul prevăzut la alin. (2) obligă operatorul de distribuţie a energiei electrice să asigure continuitatea serviciului până la pronunţarea unei hotărâri judecătoreşti definitive.</p><p class="alineat"><em class="num">(6)</em> Sistemele de iluminat public se amplasează, de regulă, pe terenuri aparţinând domeniului public sau privat al unităţilor administrativ-teritoriale.</p><p class="alineat"><em class="num">(7)</em> Utilizarea unor elemente ale sistemului de distribuţie a energiei electrice pentru servicii şi activităţi publice, altele decât iluminatul public, se face cu aprobarea autorităţilor administraţiei publice locale.</p></div></div></div><div class="document-fragment articlenumber_5" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgvpxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgu" multi-idref="L_Parlamentul_230_2006-06-07_a5" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgu');">Art. 5</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>Serviciul de iluminat public se organizează şi funcţionează cu respectarea principiilor stabilite în<a href="document-view.seam?documentId=nr4f6njrl4zdambw" multi-idref="LX_51_2006" class="" onclick="return validateLink('nr4f6njrl4zdambw');"> Legea nr. 51/2006.</a></p></div></div></div><div class="document-fragment articlenumber_6" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgzpxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgy" multi-idref="L_Parlamentul_230_2006-06-07_a6" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgy');">Art. 6</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>Organizarea şi desfăşurarea serviciului de iluminat public trebuie să asigure satisfacerea unor cerinţe şi nevoi de utilitate publică ale comunităţilor locale, şi anume:</p><p class="litera"><em class="num">a)</em> ridicarea gradului de civilizaţie, a confortului şi a calităţii vieţii;</p><p class="litera"><em class="num">b)</em> creşterea gradului de securitate individuală şi colectivă în cadrul comunităţilor locale, precum şi a gradului de siguranţă a circulaţiei rutiere şi pietonale;</p><p class="litera"><em class="num">c)</em> punerea în valoare, prin iluminat adecvat, a elementelor arhitectonice şi peisagistice ale localităţilor, precum şi marcarea evenimentelor festive şi a sărbătorilor legale sau religioase;</p><p class="litera"><em class="num">d)</em> susţinerea şi stimularea dezvoltării economico-sociale a localităţilor;</p><p class="litera"><em class="num">e)</em> funcţionarea şi exploatarea în condiţii de siguranţă, rentabilitate şi eficienţă economică a infrastructurii aferente serviciului.</p></div></div></div><div class="document-fragment articlenumber_7" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bg5pxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bg4" multi-idref="L_Parlamentul_230_2006-06-07_a7" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bg4');">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 iluminat public va respecta şi va îndeplini, la nivelul comunităţilor locale, în întregul lor, indicatorii de performanţă aprobaţi prin hotărâri ale consiliilor locale, ale asociaţiilor de dezvoltare comunitară sau ale Consiliului General al Municipiului Bucureşti, după caz.</p><p class="alineat"><em class="num">(2)</em> Indicatorii de performanţă se stabilesc cu respectarea prevederilor regulamentului-cadru al serviciului şi se aprobă în baza unui studiu de specialitate care va ţine seama cu prioritate de necesităţile comunităţilor locale, de starea tehnică şi de eficienţa sistemului de iluminat public existent.</p></div></div></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3tmnqws2k7oayxmma"><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_8" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bhbpxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bha" multi-idref="L_Parlamentul_230_2006-06-07_a8" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bha');">Art. 8</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Înfiinţarea, organizarea, coordonarea, monitorizarea şi controlul funcţionării serviciului de iluminat public la nivelul unităţilor administrativ-teritoriale, precum şi înfiinţarea, dezvoltarea, modernizarea, administrarea şi exploatarea sistemelor de iluminat public intră în competenţa exclusivă a autorităţilor administraţiei publice locale.</p><p class="alineat"><em class="num">(2)</em> Autorităţile administraţiei publice locale trebuie să asigure gestiunea serviciului de iluminat public pe criterii de competitivitate şi eficienţă economică şi managerială, având ca obiectiv atingerea şi respectarea indicatorilor de performanţă a serviciului, stabiliţi prin contractul de delegare a gestiunii, respectiv prin hotărârea de dare în administrare, în cazul gestiunii directe.</p></div></div></div><div class="document-fragment articlenumber_9" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bhfpxamlwga"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bhe" multi-idref="L_Parlamentul_230_2006-06-07_a9" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bhe');">Art. 9</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Elaborarea şi aprobarea strategiilor locale de dezvoltare a serviciului de iluminat public, a programelor de investiţii privind dezvoltarea şi modernizarea infrastructurii tehnico-edilitare aferente, a regulamentului propriu al serviciului, a caietului de sarcini, alegerea modalităţii de gestiune, precum şi a criteriilor şi procedurilor de delegare a gestiunii intră în competenţa exclusivă a consiliilor locale, a asociaţiilor de dezvoltare comunitară sau a Consiliului General al Municipiului Bucureşti, după caz.</p><p class="alineat"><em class="num">(2)</em> Strategiile şi reglementările menţionate la alin. (1) au la bază Strategia naţională privind serviciile comunitare de utilităţi publice şi ţin cont de planurile de urbanism şi de amenajare a teritoriului, de programele de dezvoltare economico-socială a unităţilor administrativ-teritoriale, precum şi de reglementările specifice domeniului, emise de autorităţile de reglementare competente.</p><p class="alineat"><em class="num">(3)</em> Strategiile autorităţilor administraţiei publice locale vor urmări cu prioritate realizarea următoarelor obiective:</p><p class="litera"><em class="num">a)</em> orientarea serviciului de iluminat public către utilizatori şi beneficiari;</p><p class="litera"><em class="num">b)</em> asigurarea calităţii şi performanţelor sistemelor de iluminat public, la nivel compatibil cu directivele Uniunii Europene;</p><p class="litera"><em class="num">c)</em> respectarea normelor privind serviciul de iluminat public stabilite de Comisia Internaţională de Iluminat, la care România este afiliată, respectiv de Comitetul Naţional Român de Iluminat, denumit în continuare <em class="italic">C.N.R.I.;</em></p><p class="litera"><em class="num">d)</em> asigurarea accesului nedescriminatoriu al tuturor membrilor comunităţii locale la serviciul de iluminat public;</p><p class="litera"><em class="num">e)</em> reducerea consumurilor specifice prin utilizarea unor corpuri de iluminat performante, a unor echipamente specializate şi prin asigurarea unui iluminat public judicios;</p><p class="litera"><em class="num">f)</em> promovarea investiţiilor, în scopul modernizării şi extinderii sistemelor de iluminat public;</p><p class="litera"><em class="num">g)</em> asigurarea, la nivelul localităţilor, a unui iluminat stradal şi pietonal adecvat necesităţilor de confort şi securitate, individuală şi colectivă, prevăzute de normele în vigoare;</p><p class="litera"><em class="num">h)</em> asigurarea unui iluminat arhitectural, ornamental şi ornamental-festiv, adecvat punerii în valoare a edificiilor de importanţă publică şi/sau culturală şi marcării prin sisteme de iluminat corespunzătoare a evenimentelor festive şi a sărbătorilor legale sau religioase;</p><p class="litera"><em class="num">i)</em> promovarea de soluţii tehnice şi tehnologice performante, cu costuri minime;</p><p class="litera"><em class="num">j)</em> promovarea mecanismelor specifice economiei de piaţă, prin crearea unui mediu concurenţial de atragere a capitalului privat;</p><p class="litera"><em class="num">k)</em> instituirea evaluării comparative a indicatorilor de performanţă a activităţii operatorilor şi participarea cetăţenilor şi a asociaţiilor reprezentative ale acestora la acest proces;</p><p class="litera"><em class="num">l)</em> promovarea formelor de gestiune delegată;</p><p class="litera"><em class="num">m)</em> promovarea metodelor moderne de management;</p><p class="litera"><em class="num">n)</em> promovarea profesionalismului, a eticii profesionale şi a formării profesionale continue a personalului ce lucrează în domeniu.</p></div></div></div><div class="document-fragment articlenumber_10" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgeyf64broyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgeya" multi-idref="L_Parlamentul_230_2006-06-07_a10" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgeya');">Art. 10</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>În exercitarea atribuţiilor şi responsabilităţilor ce le revin în domeniul administrării şi gestionării serviciului de iluminat public, autorităţile administraţiei publice locale adoptă hotărâri sau emit dispoziţii, după caz, privitoare la:</p><p class="litera"><em class="num">a)</em> aprobarea programelor de dezvoltare, reabilitare, extindere şi modernizare a sistemelor de iluminat public existente, precum şi a programelor de înfiinţare a unor noi reţele de iluminat public;</p><p class="litera"><em class="num">b)</em> coordonarea proiectării şi execuţiei lucrărilor tehnico-edilitare, în scopul realizării acestora într-o concepţie unitară şi corelată cu programele de dezvoltare economico-socială a localităţilor şi de amenajare a teritoriului, de urbanism şi de mediu;</p><p class="litera"><em class="num">c)</em> aprobarea studiilor de fezabilitate privind reabilitarea, extinderea şi modernizarea sistemelor de iluminat public, studii care vor stabili indicatorii tehnico-economici, vor identifica sursele de finanţare a investiţiilor, precum şi soluţia optimă din punct de vedere tehnico-economic;</p><p class="litera"><em class="num">d)</em> darea în administrare sau delegarea gestiunii serviciului de iluminat public, precum şi încredinţarea exploatării bunurilor aparţinând patrimoniului public sau privat al localităţilor, aferente serviciului, conform prevederilor legale;</p><p class="litera"><em class="num">e)</em> contractarea sau garantarea, în condiţiile legii, a împrumuturilor pentru finanţarea programelor de investiţii şi modernizări ale sistemelor de iluminat public;</p><p class="litera"><em class="num">f)</em> elaborarea şi aprobarea regulamentului serviciului şi a caietului de sarcini, în conformitate cu regulamentul-cadru şi caietul de sarcini-cadru, elaborate de A.N.R.S.C.;</p><p class="litera"><em class="num">g)</em> aprobarea taxelor speciale pentru prestarea serviciului de iluminat public, cu respectarea reglementărilor în vigoare;</p><p class="litera"><em class="num">h)</em> rezilierea unilaterală a contractelor de delegare a gestiunii serviciului pentru încălcarea repetată a clauzelor acestora şi pentru nerespectarea indicatorilor de performanţă a serviciului.</p></div></div></div><div class="document-fragment articlenumber_11" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgeyv64broyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgeyq" multi-idref="L_Parlamentul_230_2006-06-07_a11" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgeyq');">Art. 11</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>În raport cu comunităţile locale pe care le reprezintă, autorităţile administraţiei publice locale au următoarele responsabilităţi:</p><p class="litera"><em class="num">a)</em> să aducă la cunoştinţă publică, în condiţiile legii, hotărârile şi dispoziţiile având ca obiect serviciul de iluminat public;</p><p class="litera"><em class="num">b)</em> să stabilească şi să aprobe indicatorii de performanţă ai serviciului de iluminat public numai după ce, în prealabil, au fost supuşi dezbaterii publice;</p><p class="litera"><em class="num">c)</em> să elaboreze şi să aprobe strategia locală de dezvoltare a serviciului de iluminat public şi a infrastructurii aferente, cu consultarea prealabilă a cetăţenilor;</p><p class="litera"><em class="num">d)</em> să informeze periodic locuitorii cu privire la starea serviciului de iluminat public, la măsurile adoptate sau preconizate pentru asigurarea funcţionării acestuia, inclusiv cu privire la necesitatea instituirii unor taxe speciale pentru finanţarea investiţiilor necesare;</p><p class="litera"><em class="num">e)</em> să rezolve sesizările cu privire la deficienţele apărute în prestarea serviciului de iluminat public.</p></div></div></div><div class="document-fragment articlenumber_12" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgezf64broyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgeza" multi-idref="L_Parlamentul_230_2006-06-07_a12" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgeza');">Art. 12</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> În raport cu operatorii, autorităţile administraţiei publice locale au, pe lângă drepturile prevăzute în<a href="document-view.seam?documentId=nr4f6njrl4zdambw" multi-idref="LX_51_2006" class="" onclick="return validateLink('nr4f6njrl4zdambw');"> Legea nr. 51/2006,</a> şi următoarele drepturi:</p><p class="litera"><em class="num">a)</em> să aplice clauzele sancţionatorii, în cazul în care operatorul nu respectă prevederile hotărârii de dare în administrare sau ale contractului de delegare a gestiunii, după caz, inclusiv prevederile din regulamentul serviciului şi din caietul de sarcini anexate la acestea;</p><p class="litera"><em class="num">b)</em> să verifice respectarea clauzelor de administrare, întreţinere şi predare a bunurilor publice sau private afectate serviciului.</p><p class="alineat"><em class="num">(2)</em> Autorităţile administraţiei publice locale au faţă de operatorii serviciilor de iluminat public, pe lângă obligaţiile prevăzute în<a href="document-view.seam?documentId=nr4f6njrl4zdambw" multi-idref="LX_51_2006" class="" onclick="return validateLink('nr4f6njrl4zdambw');"> Legea nr. 51/2006,</a> şi următoarele obligaţii;</p><p class="litera"><em class="num">a)</em> să asigure şi să respecte independenţa managerială a operatorului faţă de orice ingerinţe ale autorităţilor şi instituţiilor publice;</p><p class="litera"><em class="num">b)</em> să asigure menţinerea echilibrului contractual, stabilit prin contractul prin care se deleagă gestiunea;</p><p class="litera"><em class="num">c)</em> să asigure publicitatea şi accesul liber la informaţiile de interes public, cu precădere la acele informaţii care asigură pregătirea ofertelor şi participarea la procedurile de delegare a gestiunii serviciului.</p></div></div></div><div class="document-fragment articlenumber_13" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgezv64broyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgezq" multi-idref="L_Parlamentul_230_2006-06-07_a13" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bgezq');">Art. 13</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>Împotriva hotărârilor sau dispoziţiilor autorităţilor administraţiei publice locale, date în aplicarea prezentei legi, persoanele fizice sau persoanele juridice interesate se pot adresa instanţei de contencios administrativ, în condiţiile legii.</p></div></div></div><div class="document-fragment articlenumber_14" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge2f64broyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge2a" multi-idref="L_Parlamentul_230_2006-06-07_a14" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge2a');">Art. 14</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p>Unităţile administrativ-teritoriale se pot asocia între ele în vederea înfiinţării, realizării şi exploatării în interes comun a serviciului de iluminat public şi a infrastructurii 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></p></div></div></div><div class="document-fragment articlenumber_15" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge2v64broyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge2q" multi-idref="L_Parlamentul_230_2006-06-07_a15" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge2q');">Art. 15</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Autoritatea de reglementare competentă pentru serviciul de iluminat public, A.N.R.S.C., îşi exercită competenţele şi atribuţiile care îi sunt acordate prin<a href="document-view.seam?documentId=nr4f6njrl4zdambw" multi-idref="LX_51_2006" class="" onclick="return validateLink('nr4f6njrl4zdambw');"> Legea nr. 51/2006 </a>faţă de autorităţile administraţiei publice locale şi faţă de toţi operatorii, indiferent de forma de organizare, natura capitalului, ţara de origine sau modalitatea de gestiune adoptată.</p><p class="alineat"><em class="num">(2)</em> A.N.R.S.C., în colaborare cu C.N.R.I., va realiza şi va dezvolta un sistem informaţional ce va permite colectarea, monitorizarea şi compararea continuă a fiecărui indicator de performanţă specific serviciului de iluminat public cu nivelul atins de operatorul cel mai performant în domeniu.</p><p class="alineat"><em class="num">(3)</em> Autorităţile administraţiei publice locale au acces la orice informaţie de interes public deţinută de A.N.R.S.C. cu privire la serviciul de iluminat public.</p></div></div></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3tmnqws2ljl5ydc5rq"><div class="title"><div class="title"><h1 class="number"><em class="num">CAPITOLUL III</em></h1><h1 class="line-1">Organizarea şi funcţionarea serviciului de iluminat public</h1></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3tmnqws2ljl5zxgzjrl5ydc5rq"><div class="title"><div class="title"><h1 class="number"><em class="num">SECŢIUNEA 1</em></h1><h1 class="line-1">Gestiunea serviciului de iluminat public</h1></div></div><div class="document-fragment articlenumber_16" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge3f64broyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge3a" multi-idref="L_Parlamentul_230_2006-06-07_a16" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge3a');">Art. 16</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Gestiunea serviciului de iluminat public se realizează prin următoarele modalităţi:</p><p class="litera"><em class="num">a)</em> gestiune directă;</p><p class="litera"><em class="num">b)</em> gestiune delegată.</p><p class="alineat"><em class="num">(2)</em> Alegerea formei de gestiune a serviciului de iluminat public se face prin hotărâre a consiliilor locale, a Consiliului General al Municipiului Bucureşti sau a asociaţiilor de dezvoltare comunitară, după caz.</p></div></div></div><div class="document-fragment articlenumber_17" id="document_fragment_nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge3v64broyya"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge3q" multi-idref="L_Parlamentul_230_2006-06-07_a17" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzsgmyf6mrqga3c2mbwfuydox3bge3q');">Art. 17</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Indiferent de forma de gestiune adoptată, în virtutea competenţelor şi atribuţiilor ce le revin potrivit legii, autorităţile administraţiei publice locale păstrează dreptul de a aproba, a supraveghea şi a controla, după caz:</p><p class="litera"><em class="num">a)</em> modul de fundamentare a tarifelor şi respectarea metodologiei de stabilire, ajustare sau de modificare a acestora, emise de A.N.R.S.C.;</p><p class="litera"><em class="num">b)</em> modul de îndeplinire a obligaţiilor contractuale asumate de operatori şi activităţile desfăşurate de aceştia;</p><p class="litera"><em class="num">c)</em> calitatea şi eficienţa serviciului prestat, corespunzător indicatorilor de performanţă a serviciului, stabiliţi conform legii;</p><p class="litera"><em class="num">d)</em> modul de administrare, de exploatare, de conservare şi de menţinere în funcţiune, dezvoltarea şi/sau modernizarea sistemului de iluminat public.</p><p class="alineat"><em class="num">(2)</em> Activităţile specifice serviciului de iluminat public, indiferent de forma de gestiune adoptată, se organizează şi se desfăşoară în conformitate cu prevederile regulamentului propriu al serviciului de iluminat public şi ale caietului de sarcini, elaborate şi aprobate de consiliile locale, de Consiliul General al Municipiului Bucureşti sau de asociaţiile de dezvoltare comunitară, după caz, în baza regulamentului-cadru al serviciului de iluminat public şi a caietului de sarcini-cadru, elabo