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_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf64broy2q"><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. 92</span>/<span class="year">2007</span></p><div class="title"><h2 class="title_line_2">serviciilor de transport public local</h2></div><p class="mocit"><a href="document-view.seam?documentId=nvxv6mrqga3v6mrwgi" multi-idref="MO_2007_262" class="" onclick="return validateLink('nvxv6mrqga3v6mrwgi');">M.Of. nr. 262 din 19.4.2007</a></p></div></div><div class="modificat"><table class="modif"><tr><th>Nr.</th><th>Titlu</th><th>Data</th><th>MO</th><th>Modificări</th></tr><tr><td class="num">1</td><td class="title"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzyl4zdamjsfuydcljqgzpxamlwga" multi-idref="L_Parlamentul_8_2012-01-06_P1V0" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzyl4zdamjsfuydcljqgzpxamlwga');">Lege nr. 8/2012</a> - pentru aprobarea Ordonanţei Guvernului nr. 21/2011 privind înfiinţarea Autorităţii Metropolitane de Transport Bucureşti</td><td class="date">13 ianuarie 2012</td><td class="src"><a href="document-view.seam?documentId=nvxv6mrqgezf6mrq" multi-idref="MO_2012_20" class="" onclick="return validateLink('nvxv6mrqgezf6mrq');">M. Of. 20/2012</a></td><td class="dest"><span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjul5ydc5rv" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjul5ydc5rv');">Art. 4</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjvl5ydc5rv" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjvl5ydc5rv');">Art. 5</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrgzpxamlwgu" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrgzpxamlwgu');">Art. 16</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjtg5pxamlwgu" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjtg5pxamlwgu');">Art. 37</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugvpxamlwgu" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugvpxamlwgu');">Art. 45</a></span></td></tr><tr><td class="num">2</td><td class="title"><a href="document-view.seam?documentId=n5tv6z3vozsxe3tvnrptemk7giydcmjnga4c2mzql5ydc5rq" multi-idref="OG_Guvernul_21_2011-08-30_P1V0" class="" onclick="return validateLink('n5tv6z3vozsxe3tvnrptemk7giydcmjnga4c2mzql5ydc5rq');">Ordonanţă nr. 21/2011</a> - privind înfiinţarea Autorităţii Metropolitane de Transport Bucureşti</td><td class="date">04 septembrie 2011</td><td class="src"><a href="document-view.seam?documentId=nvxv6mrqgeyv6nrsgm" multi-idref="MO_2011_623" class="" onclick="return validateLink('nvxv6mrqgeyv6nrsgm');">M. Of. 623/2011</a></td><td class="dest"><span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjsgbpxamlwgq" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjsgbpxamlwgq');">Art. 20</a></span></td></tr><tr><td class="num">3</td><td class="title"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzrgyzv6mrqgeys2mbxfuytcx3qgf3da" multi-idref="L_Parlamentul_163_2011-07-11_P1V0" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzrgyzv6mrqgeys2mbxfuytcx3qgf3da');">Lege nr. 163/2011</a> - pentru modificarea şi completarea Legii serviciilor de transport public local nr. 92/2007</td><td class="date">25 iulie 2011</td><td class="src"><a href="document-view.seam?documentId=nvxv6mrqgeyv6njrhe" multi-idref="MO_2011_519" class="" onclick="return validateLink('nvxv6mrqgeyv6njrhe');">M. Of. 519/2011</a></td><td class="dest"><span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjul5ydc5rv" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjul5ydc5rv');">Art. 4</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjvl5ydc5rv" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjvl5ydc5rv');">Art. 5</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrgrpxamlwgm" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrgrpxamlwgm');">Art. 14</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrgzpxamlwgu" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrgzpxamlwgu');">Art. 16</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrg5pxamlwgm" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrg5pxamlwgm');">Art. 17</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjsgbpxamlwgq" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjsgbpxamlwgq');">Art. 20</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjsgrpxamlwgm" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjsgrpxamlwgm');">Art. 24</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjtg5pxamlwgu" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjtg5pxamlwgu');">Art. 37</a></span></td></tr><tr><td class="num">4</td><td class="title"><a href="document-view.seam?documentId=n52wox3hov3gk4toovwf6mzul4zdamjqfuydiljrgjpxamlwge" multi-idref="OUG_Guvernul_34_2010-04-12_P1V1" class="" onclick="return validateLink('n52wox3hov3gk4toovwf6mzul4zdamjqfuydiljrgjpxamlwge');">Ordonanţă de urgenţă nr. 34/2010</a> - privind unele măsuri pentru întărirea controlului în scopul combaterii transporturilor ilicite de mărfuri şi de persoane</td><td class="date">24 iulie 2010</td><td class="src"><a href="document-view.seam?documentId=nvxv6mrqgeyf6mrtgq" multi-idref="MO_2010_234" class="" onclick="return validateLink('nvxv6mrqgeyf6mrtgq');">M. Of. 234/2010</a></td><td class="dest"><span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugvpxamlwgu" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugvpxamlwgu');">Art. 45</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugzztcx3qgf3de" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugzztcx3qgf3de');">Art. 46<sup>1</sup></a></span></td></tr><tr><td class="num">5</td><td class="title"><a href="document-view.seam?documentId=n52wox3hov3gk4toovwf6mzul4zdamjqfuydiljrgjpxamlwga" multi-idref="OUG_Guvernul_34_2010-04-12_P1V0" class="" onclick="return validateLink('n52wox3hov3gk4toovwf6mzul4zdamjqfuydiljrgjpxamlwga');">Ordonanţă de urgenţă nr. 34/2010</a> - privind unele măsuri pentru întărirea controlului în scopul combaterii transporturilor ilicite de mărfuri şi de persoane</td><td class="date">13 aprilie 2010</td><td class="src"><a href="document-view.seam?documentId=nvxv6mrqgeyf6mrtgq" multi-idref="MO_2010_234" class="" onclick="return validateLink('nvxv6mrqgeyf6mrtgq');">M. Of. 234/2010</a></td><td class="dest"><span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugvpxamlwgu" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugvpxamlwgu');">Art. 45</a></span>, <span class="legal_rule"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugzztcx3qgf3de" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjugzztcx3qgf3de');">Art. 46<sup>1</sup></a></span></td></tr></table></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_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf643dmfuv64broyya"><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_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjrl5ydc5rq"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjr" multi-idref="L_Parlamentul_92_2007-04-10_a1" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjr');">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 are ca obiect stabilirea cadrului juridic privind înfiinţarea, autorizarea, organizarea, exploatarea, gestionarea, finanţarea şi controlul funcţionării serviciilor de transport public în comune, oraşe, municipii, judeţe şi în zonele asociaţiilor de dezvoltare comunitară.</p><p class="alineat"><em class="num">(2)</em> Prezenta lege stabileşte cadrul juridic privind înfiinţarea, organizarea şi funcţionarea compartimentelor sau serviciilor specializate de transport din cadrul autorităţilor administraţiei publice locale, judeţene şi ale municipiului Bucureşti.</p><p class="alineat"><em class="num">(3)</em> Transportul local de persoane şi de mărfuri poate fi transport public sau transport în cont propriu, aşa cum acestea sunt definite în Ordonanţa de urgenţă a Guvernului nr. 109/2005 privind transporturile rutiere, aprobată cu modificări şi completări prin<a href="document-view.seam?documentId=nr4f6mjqgjptembqgy" multi-idref="LX_102_2006" class="" onclick="return validateLink('nr4f6mjqgjptembqgy');"> Legea nr. 102/2006,</a> cu modificările ulterioare.</p><p class="alineat"><em class="num">(4)</em> Serviciul de transport public local de persoane şi de mărfuri se organizează de către autorităţile administraţiei publice locale, pe raza administrativ-teritorială respectivă, cu respectarea următoarelor principii:</p><p class="litera"><em class="num">a)</em> promovarea concurenţei între operatorii de transport, respectiv transportatorii autorizaţi, cărora li s-a atribuit executarea serviciului;</p><p class="litera"><em class="num">b)</em> garantarea accesului egal şi nediscriminatoriu al operatorilor de transport şi al transportatorilor autorizaţi la piaţa transportului public local;</p><p class="litera"><em class="num">c)</em> garantarea respectării drepturilor şi intereselor utilizatorilor serviciului de transport public local;</p><p class="litera"><em class="num">d)</em> rezolvarea problemelor de ordin economic, social şi de mediu ale localităţilor sau judeţului respectiv;</p><p class="litera"><em class="num">e)</em> administrarea eficientă a bunurilor aparţinând sistemelor de transport proprietate a unităţilor administrativ-teritoriale;</p><p class="litera"><em class="num">f)</em> utilizarea eficientă a fondurilor publice în activitatea de administrare sau executare a serviciului de transport public local;</p><p class="litera"><em class="num">g)</em> deplasarea în condiţii de siguranţă şi de confort, inclusiv prin asigurarea de risc a mărfurilor şi a persoanelor transportate, precum şi a bunurilor acestora prin poliţe de asigurări;</p><p class="litera"><em class="num">h)</em> asigurarea executării unui transport public local suportabil în ceea ce priveşte tariful de transport;</p><p class="litera"><em class="num">i)</em> recuperarea integrală a costurilor de exploatare, reabilitare şi dezvoltare prin tarife/taxe suportate de către beneficiarii direcţi ai transportului, denumiţi în continuare <em class="italic">utilizatori,</em> şi prin finanţarea de la bugetele locale, asigurându-se un profit rezonabil pentru operatorii de transport şi transportatorii autorizaţi;</p><p class="litera"><em class="num">j)</em> autonomia sau independenţa financiară a operatorilor de transport şi a transportatorilor autorizaţi;</p><p class="litera"><em class="num">k)</em> susţinerea dezvoltării economice a localităţilor prin realizarea unei infrastructuri de transport moderne;</p><p class="litera"><em class="num">l)</em> satisfacerea cu prioritate a nevoilor de deplasare ale populaţiei, ale personalului instituţiilor publice şi ale operatorilor economici pe teritoriul unităţilor administrativ-teritoriale prin servicii de calitate;</p><p class="litera"><em class="num">m)</em> protecţia categoriilor sociale defavorizate, prin compensarea costului transportului de la bugetul local;</p><p class="litera"><em class="num">n)</em> integrarea tarifară prin utilizarea unui singur tip de legitimaţie de călătorie pentru toate mijloacele de transport public local de persoane prin curse regulate;</p><p class="litera"><em class="num">o)</em> dispecerizarea transportului public local de persoane realizat prin programe permanente;</p><p class="litera"><em class="num">p)</em> consultarea asociaţiilor reprezentative ale operatorilor de transport şi/sau ale transportatorilor autorizaţi, precum şi ale utilizatorilor în vederea stabilirii politicilor şi strategiilor locale privind transportul public local şi modalităţile de funcţionare a acestui serviciu.</p><p class="alineat"><em class="num">(5)</em> Statul sprijină prin măsuri legislative şi economice dezvoltarea cantitativă şi calitativă a serviciilor de transport public local, precum şi a infrastructurii tehnico-edilitare aferente sistemului de transport public local.</p><p class="alineat"><em class="num">(6)</em> Principalele obiective urmărite de autorităţile administraţiei publice locale în domeniul serviciului de transport public local sunt:</p><p class="litera"><em class="num">a)</em> înfiinţarea de compartimente sau servicii de specialitate pentru transportul public local, cu sau fără personalitate juridică, după caz, denumite în continuare <em class="italic">autorităţi locale de transport;</em></p><p class="litera"><em class="num">b)</em> asigurarea finanţării necesare dezvoltării componentelor sistemului de transport public local, în condiţiile în care acestea aparţin domeniului public sau privat al autorităţilor administraţiei publice locale;</p><p class="litera"><em class="num">c)</em> asigurarea transparenţei în procedurile de achiziţie publică;</p><p class="litera"><em class="num">d)</em> informarea şi consultarea periodică a populaţiei asupra politicilor de dezvoltare durabilă din domeniul serviciului de transport public local;</p><p class="litera"><em class="num">e)</em> acordarea unor facilităţi de transport anumitor categorii de persoane;</p><p class="litera"><em class="num">f)</em> corelarea capacităţii mijloacelor de transport de persoane cu fluxurile de călători existente;</p><p class="litera"><em class="num">g)</em> asigurarea continuităţii serviciilor de transport prin programele de transport sau de funcţionare, după caz, corelate cu fluxurile de călători sau de mărfuri existente;</p><p class="litera"><em class="num">h)</em> atribuirea serviciilor de transport public local operatorilor de transport rutier şi transportatorilor autorizaţi, în funcţie de nivelul efortului investiţional al acestora realizat în mijloacele de transport şi în infrastructura de transport.</p><p class="alineat"><em class="num">(7)</em> Serviciile de transport public local se desfăşoară cu respectarea reglementărilor în vigoare privind legalitatea transportului, condiţiile de lucru, de exploatare a vehiculelor şi de exploatare a infrastructurii, precum şi condiţiile privind siguranţa circulaţiei.</p><p class="alineat"><em class="num">(8)</em> În toate raporturile generate de executarea serviciilor de transport public local, protecţia vieţii umane şi a mediului este prioritară.</p></div></div></div><div class="document-fragment articlenumber_2" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjsl5ydc5rq"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjs" multi-idref="L_Parlamentul_92_2007-04-10_a2" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjs');">Art. 2</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> În condiţiile în care în transportul public local se acordă facilităţi de transport uneia sau mai multor categorii de persoane, serviciul prin care se realizează transportul respectiv se consideră serviciu public subvenţionat de transport.</p><p class="alineat"><em class="num">(2)</em> Serviciul public subvenţionat de transport se efectuează în conformitate cu prevederile prezentei legi şi ale Ordonanţei Guvernului nr. 97/1999 privind garantarea furnizării de servicii publice subvenţionate de transport rutier intern şi de transport pe căile navigabile interioare, republicată.</p><p class="alineat"><em class="num">(3)</em> Serviciul public subvenţionat de transport se realizează în condiţiile îndeplinirii tuturor obligaţiilor de exploatare, a obligaţiilor de transport şi a obligaţiilor tarifare, aşa cum acestea sunt definite în<a href="document-view.seam?documentId=n5tv6ojxl4ytsojz" multi-idref="OG_97_1999" class="" onclick="return validateLink('n5tv6ojxl4ytsojz');"> Ordonanţa Guvernului nr. 97/1999,</a> republicată.</p></div></div></div><div class="document-fragment articlenumber_3" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjtl5ydc5rq"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjt" multi-idref="L_Parlamentul_92_2007-04-10_a3" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjt');">Art. 3</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Serviciile de transport public local fac parte din sfera serviciilor comunitare de utilitate publică şi cuprind 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 controlul, conducerea sau coordonarea autorităţilor administraţiei publice locale, în scopul asigurării transportului public local, precum şi a transportului public judeţean de persoane.</p><p class="alineat"><em class="num">(2)</em> Serviciile de transport public local includ serviciile de transport public de persoane, serviciile de transport public de mărfuri, precum şi alte servicii de transport public.</p><p class="alineat"><em class="num">(3)</em> Serviciile de transport public local de persoane cuprind:</p><p class="litera"><em class="num">a)</em> transport prin curse regulate;</p><p class="litera"><em class="num">b)</em> transport prin curse regulate speciale;</p><p class="litera"><em class="num">c)</em> transport cu autoturisme în regim de taxi;</p><p class="litera"><em class="num">d)</em> transport cu autoturisme în regim de închiriere.</p><p class="alineat"><em class="num">(4)</em> Serviciile de transport public local de mărfuri, în sensul prezentei legi, sunt transporturile publice efectuate cu autovehicule a căror masă maximă autorizată, cu tot cu remorcă, nu depăşeşte 3,5 tone şi cuprind:</p><p class="litera"><em class="num">a)</em> transportul în regim contractual;</p><p class="litera"><em class="num">b)</em> transportul în regim de taxi.</p><p class="alineat"><em class="num">(5)</em> Alte servicii de transport public local cuprind:</p><p class="litera"><em class="num">a)</em> transport de persoane pe cablu;</p><p class="litera"><em class="num">b)</em> transporturi de mărfuri efectuate cu tractoare cu remorci;</p><p class="litera"><em class="num">c)</em> transporturi de persoane şi mărfuri pe căi navigabile interioare;</p><p class="litera"><em class="num">d)</em> transporturi efectuate cu vehicule speciale destinate serviciilor funerare.</p></div></div></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf643dmfuwsx3qgf3da"><div class="title"><div class="title"><h1 class="number"><em class="num">CAPITOLUL II</em></h1><h1 class="line-1">Serviciile de transport public local de persoane</h1></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf643dmfuwsx3tonstcx3qgf3da"><div class="title"><div class="title"><h1 class="number"><em class="num">SECŢIUNEA 1</em></h1><h1 class="line-1">Serviciul de transport public local de persoane prin curse regulate</h1></div></div><div class="document-fragment articlenumber_4" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjul5ydc5rv"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yju" multi-idref="L_Parlamentul_92_2007-04-10_a4" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yju');">Art. 4</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Este considerat serviciu de transport public local de persoane prin curse regulate transportul public care îndeplineşte cumulativ următoarele condiţii:</p><p class="litera"><em class="num">a)</em> se efectuează de către un operator de transport rutier, astfel cum acesta este definit şi licenţiat conform prevederilor Ordonanţei de urgenţă a Guvernului nr. 109/2005, aprobată cu modificări şi completări prin<a href="document-view.seam?documentId=nr4f6mjqgjptembqgy" multi-idref="LX_102_2006" class="" onclick="return validateLink('nr4f6mjqgjptembqgy');"> Legea nr. 102/2006,</a> cu modificările ulterioare, sau de către un transportator autorizat, aşa cum acesta este definit şi autorizat conform prevederilor prezentei legi;</p><del><p class="litera"><em class="num">b)</em> se efectuează numai pe raza teritorial-administrativă a unei localităţi, în cazul transportului local, sau numai între localităţile unui judeţ, în cazul transportului judeţean, În cazul în care traseul transportului pe şină depăşeşte limita localităţii, acesta va fi considerat transport public local;</p></del><ins><p class="litera"><em class="num">b)</em> se efectuează pe raza teritorial-administrativă a unei localităţi, respectiv pe raza administrativ-teritorială a zonei metropolitane, sau numai între localităţile unui judeţ, în funcţie de tipul de transport stabilit potrivit legii. În cazul în care traseul transportului pe şină depăşeşte limita localităţii, acesta va fi considerat transport public local;</p></ins><del><p class="litera"><em class="num">c)</em> se execută pe rute şi cu programe de circulaţie prestabilite de către consiliul local, consiliul judeţean sau Consiliul General al Municipiului Bucureşti;</p></del><ins><p class="litera"><em class="num">c)</em> se execută pe rute şi cu programe de circulaţie prestabilite de către autorităţile competente desemnate potrivit legii;</p></ins><p class="litera"><em class="num">d)</em> se efectuează de către operatorul de transport rutier sau transportatorul autorizat cu mijloace de transport în comun, respectiv cu autobuze, troleibuze, tramvaie sau metrou, deţinute în proprietate sau în baza unui contract de leasing, înmatriculate sau înregistrate, după caz, în judeţul sau localitatea respectivă. În condiţiile prezentei legi, transportul realizat cu troleibuze, tramvaie sau metrou se realizează de către transportatorii autorizaţi;</p><p class="litera"><em class="num">e)</em> persoanele transportate sunt îmbarcate sau debarcate în puncte fixe prestabilite, denumite <em class="italic">staţii</em> sau <em class="italic">autogări,</em> după caz;</p><p class="litera"><em class="num">f)</em> pentru efectuarea serviciului, operatorul de transport rutier sau transportatorul autorizat percepe de la persoanele transportate un tarif de transport pe bază de legitimaţii de călătorie individuale eliberate anticipat, al căror regim este stabilit de Ordonanţa de urgenţă a Guvernului nr. 109/2005, aprobată cu modificări şi completări prin<a href="document-view.seam?documentId=nr4f6mjqgjptembqgy" multi-idref="LX_102_2006" class="" onclick="return validateLink('nr4f6mjqgjptembqgy');"> Legea nr. 102/2006,</a> cu modificările ulterioare;</p><del><p class="litera"><em class="num">g)</em> transportul cu autobuzele se efectuează numai pe bază de licenţe de traseu şi caiete de sarcini, elaborate şi eliberate în condiţiile stabilite prin normele de aplicare elaborate de Ministerul Administraţiei şi Internelor<span class="footnote"><a title="Notă" href="#" onclick="displayFootnote('d5576807e842', 'Notă', 300)"><sup>*)</sup></a></span> şi aprobate prin ordin al ministrului, denumite în continuare <em class="italic">Norme.</em></p></del><ins><p class="litera"><em class="num">g)</em> transportul cu autobuzele se efectuează numai pe bază de licenţe de traseu şi caiete de sarcini, elaborate şi eliberate în condiţiile stabilite prin normele de aplicare elaborate şi aprobate prin ordin comun al ministrului administraţiei şi internelor şi al ministrului transporturilor şi infrastructurii, denumite în continuare <em class="italic">Norme.</em></p></ins><del><p class="alineat"><em class="num">(1<sup>1</sup>)</em> Pentru efectuarea serviciului de transport public de persoane prin curse regulate, pe traseele dintre municipiul Bucureşti şi localităţile judeţului Ilfov, operatorii de transport care deţin licenţele respective pot utiliza şi autobuze urbane, în condiţiile în care Consiliul Judeţean Ilfov stabileşte astfel în licenţele de traseu.</p></del><ins><p class="alineat"><em class="num">(1<sup>1</sup>)</em> Abrogat.</p></ins><p class="alineat"><em class="num">(2)</em> Conducătorul mijlocului de transport în comun este obligat să prezinte la controlul în trafic următoarele documente, după caz:</p><p class="litera"><em class="num">a)</em> licenţa de traseu şi caietul de sarcini al acesteia eliberat de emitentul licenţei;</p><p class="litera"><em class="num">b)</em> programul de circulaţie;</p><p class="litera"><em class="num">c)</em> copia conformă a licenţei de transport, în cazul autobuzelor;</p><p class="litera"><em class="num">d)</em> alte documente stabilite de legile în vigoare.</p></div></div><div class="modif"><h2>modificat de</h2><p><span><span><a href="document-view.seam?documentId=nr4f6oc7giydcmq" multi-idref="LX_8_2012" class="" onclick="return validateLink('nr4f6oc7giydcmq');">Lege nr. 8/2012 </a>- pentru aprobarea Ordonanţei Guvernului nr. 21/2011 privind înfiinţarea Autorităţii Metropolitane de Transport Bucureşti</span> din <span class="date">6 ianuarie 2012</span>, <span class="src"><a href="document-view.seam?documentId=nvxv6mrqgezf6mrq" multi-idref="MO_2012_20" class="" onclick="return validateLink('nvxv6mrqgezf6mrq');">M. Of. 20/2012</a></span>;</span></p><p><span><span><a href="document-view.seam?documentId=nr4f6mjwgnptembrge" multi-idref="LX_163_2011" class="" onclick="return validateLink('nr4f6mjwgnptembrge');">Lege nr. 163/2011 </a>- pentru modificarea şi completarea Legii serviciilor de transport public local nr. 92/2007</span> din <span class="date">11 iulie 2011</span>, <span class="src"><a href="document-view.seam?documentId=nvxv6mrqgeyv6njrhe" multi-idref="MO_2011_519" class="" onclick="return validateLink('nvxv6mrqgeyv6njrhe');">M. Of. 519/2011</a></span>;</span></p></div></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf643dmfuwsx3tonstex3qgf3da"><div class="title"><div class="title"><h1 class="number"><em class="num">SECŢIUNEA a 2-a</em></h1><h1 class="line-1">Serviciul de transport public local de persoane prin curse regulate speciale</h1></div></div><div class="document-fragment articlenumber_5" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjvl5ydc5rv"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjv" multi-idref="L_Parlamentul_92_2007-04-10_a5" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjv');">Art. 5</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Este considerat <em class="italic">serviciu de transport public local de persoane prin curse regulate speciale</em> transportul public efectuat tur-retur, pe rute şi cu programe de transport prestabilite de către beneficiarul serviciului de transport sau de către cel care a angajat serviciul privind transportul unor persoane sau al unor grupuri de persoane, şi anume: transportul copiilor, elevilor şi studenţilor la şi de la instituţiile de învăţământ, transportul salariaţilor la şi de la instituţiile la care sunt salariaţi sau transportul angajaţilor unui operator economic la şi de la locul de muncă.</p><p class="alineat"><em class="num">(2)</em> Transportul public local de persoane prin curse regulate speciale se poate desfăşura pe teritoriul localităţii de autorizare sau între aceasta şi orice altă localitate de pe raza judeţului respectiv.</p><del><p class="alineat"><em class="num">(3)</em> Transportul public local de persoane prin curse regulate speciale locale sau judeţene se realizează de către operatorii de transport rutier cu autobuze deţinute în proprietate sau în baza unui contract de leasing pe bază de licenţe de traseu şi caiete de sarcini elaborate şi eliberate de primărie sau de consiliul judeţean, după caz, în condiţiile stabilite prin Norme.</p></del><ins><p class="alineat"><em class="num">(3)</em> Abrogat.</p></ins><p class="alineat"><em class="num">(4)</em> Serviciul de transport public local de persoane prin curse regulate speciale trebuie să întrunească cumulativ următoarele condiţii:</p><p class="litera"><em class="num">a)</em> se execută cu autobuze deţinute în proprietate, înmatriculate în judeţul respectiv, sau în baza unui contract de leasing, pe baza unor programe de circulaţie stabilite de către cel care a angajat transportul cu operatorul de transport rutier;</p><p class="litera"><em class="num">b)</em> se execută de către un operator de transport astfel cum este definit şi licenţiat conform Ordonanţei de urgenţă a Guvernului nr. 109/2005, aprobată cu modificări şi completări prin<a href="document-view.seam?documentId=nr4f6mjqgjptembqgy" multi-idref="LX_102_2006" class="" onclick="return validateLink('nr4f6mjqgjptembqgy');"> Legea nr. 102/2006,</a> cu modificările ulterioare;</p><p class="litera"><em class="num">c)</em> persoanele transportate se îmbarcă şi se debarcă în staţii stabilite special, în locul unde îşi desfăşoară activitatea sau la domiciliu/reşedinţă;</p><p class="litera"><em class="num">d)</em> operatorul de transport rutier încasează de la beneficiarul transportului sau de la cel care a angajat transportul contravaloarea serviciului stabilită în conformitate cu prevederile contractului de transport încheiat între aceştia;</p><p class="litera"><em class="num">e)</em> persoanele transportate se legitimează pe baza legitimaţiei de serviciu valabile.</p><p class="alineat"><em class="num">(5)</em> Conducătorul autobuzului este obligat să prezinte la controlul în trafic următoarele documente:</p><p class="litera"><em class="num">a)</em> contractul de transport încheiat între beneficiarul transportului sau persoana care a angajat transportul şi operatorul de transport rutier;</p><p class="litera"><em class="num">b)</em> lista persoanelor transportate, ca anexă la contractul de transport;</p><p class="litera"><em class="num">c)</em> licenţa de traseu şi caietul de sarcini al acesteia eliberat de emitentul licenţei;</p><p class="litera"><em class="num">d)</em> copia conformă a licenţei de transport;</p><p class="litera"><em class="num">e)</em> alte documente prevăzute de legile în vigoare.</p></div></div><div class="modif"><h2>modificat de</h2><p><span><span><a href="document-view.seam?documentId=nr4f6oc7giydcmq" multi-idref="LX_8_2012" class="" onclick="return validateLink('nr4f6oc7giydcmq');">Lege nr. 8/2012 </a>- pentru aprobarea Ordonanţei Guvernului nr. 21/2011 privind înfiinţarea Autorităţii Metropolitane de Transport Bucureşti</span> din <span class="date">6 ianuarie 2012</span>, <span class="src"><a href="document-view.seam?documentId=nvxv6mrqgezf6mrq" multi-idref="MO_2012_20" class="" onclick="return validateLink('nvxv6mrqgezf6mrq');">M. Of. 20/2012</a></span>;</span></p><p><span><span><a href="document-view.seam?documentId=nr4f6mjwgnptembrge" multi-idref="LX_163_2011" class="" onclick="return validateLink('nr4f6mjwgnptembrge');">Lege nr. 163/2011 </a>- pentru modificarea şi completarea Legii serviciilor de transport public local nr. 92/2007</span> din <span class="date">11 iulie 2011</span>, <span class="src"><a href="document-view.seam?documentId=nvxv6mrqgeyv6njrhe" multi-idref="MO_2011_519" class="" onclick="return validateLink('nvxv6mrqgeyv6njrhe');">M. Of. 519/2011</a></span>;</span></p></div></div></div><div class="document-fragment" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf643dmfuwsx3tonstgx3qgf3da"><div class="title"><div class="title"><h1 class="number"><em class="num">SECŢIUNEA a 3-a</em></h1><h1 class="line-1">Serviciul de transport cu autoturisme în regim de taxi şi de transport cu autoturisme în regim de închiriere</h1></div></div><div class="document-fragment articlenumber_6" id="document_fragment_nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjwl5ydc5rq"><div class="title"><div class="title"><h1 class="number"><em class="num"><a href="document-view.seam?documentId=nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjw" multi-idref="L_Parlamentul_92_2007-04-10_a6" class="" onclick="return validateLink('nrpxaylsnrqw2zloor2wyxzzgjptembqg4wtanbngeyf6yjw');">Art. 6</a></em></h1></div></div><div class="legal_text"><div class="legal_text"><p class="alineat"><em class="num">(1)</em> Serviciul de transport public de persoane realizat în regim de taxi sau transportul public de persoane realizat cu autoturisme în regim de închiriere se organizează ca serviciu de utilitate publică care asigură nevoia de deplasare a populaţiei din localitate sau a celei aflate în tranzit.</p><p class="alineat"><em class="num">(2)</em> Transportul în regim de taxi se efectuează în localitatea de autorizare şi, ocazional, între aceasta şi orice altă localitate, cu obligaţia revenirii autoturismului în localitatea de autorizare după efectuarea fiecărei curse.</p><p class="alineat"><em class="num">(3)</em> Transportul cu autoturisme în regim de închiriere se efectuează în localitatea de autorizare sau între aceasta şi orice altă localitate, cu obligaţia revenirii autovehiculului în localitatea de autorizare după efectuarea transportului conform contractului.</p><p class="alineat"><em class="num">(4)</em> Transportul în regim de taxi sau transportul în regim de închiriere se efectuează de către transportatorii autorizaţi, precum şi de compartimentele sau serviciile de specialitate ale primăriei.