<!DOCTYPE html>
<html class="client-nojs" lang="en" dir="ltr">
<head>
<meta charset="UTF-8"/>
<title>File:Flag of Syria.svg - Wikimedia Commons</title>
<script>document.documentElement.className = document.documentElement.className.replace( /(^|\s)client-nojs(\s|$)/, "$1client-js$2" );</script>
<script>(window.RLQ=window.RLQ||[]).push(function(){mw.config.set({"wgCanonicalNamespace":"File","wgCanonicalSpecialPageName":false,"wgNamespaceNumber":6,"wgPageName":"File:Flag_of_Syria.svg","wgTitle":"Flag of Syria.svg","wgCurRevisionId":210166516,"wgRevisionId":210166516,"wgArticleId":363156,"wgIsArticle":true,"wgIsRedirect":false,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":["Derivative versions","Valid SVG created with Other tools:Flags","Self-published work","PD-self","SVG flags of Syria","Flags with three horizontal stripes of black, red and white (centered) color combination","Flags with two green five-pointed stars","SVG flags with an aspect ratio of 3:2","SVG sovereign state flags"],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgPageContentModel":"wikitext","wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgMonthNamesShort":["","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgRelevantPageName":"File:Flag_of_Syria.svg","wgRelevantArticleId":363156,"wgRequestId":"WbRWTQpAEKsAAFdE-@YAAABJ","wgIsProbablyEditable":false,"wgRelevantPageIsProbablyEditable":false,"wgRestrictionEdit":["autoconfirmed"],"wgRestrictionMove":["sysop"],"wgRestrictionUpload":["sysop"],"wgWikiEditorEnabledModules":{"toolbar":true,"preview":false,"publish":false},"wgBetaFeaturesFeatures":[],"wgMediaViewerOnClick":true,"wgMediaViewerEnabledByDefault":false,"wgVisualEditor":{"pageLanguageCode":"en","pageLanguageDir":"ltr","pageVariantFallbacks":"en","usePageImages":true,"usePageDescriptions":true},"wgPreferredVariant":"en","wgMFExpandAllSectionsUserOption":false,"wgMFDisplayWikibaseDescriptions":{"search":true,"nearby":true,"watchlist":true,"tagline":true},"wgULSCurrentAutonym":"English","wgNoticeProject":"commons","wgCentralNoticeCookiesToDelete":[],"wgCentralNoticeCategoriesUsingLegacy":["Fundraising","fundraising"],"wgCategoryTreePageCategoryOptions":"{\"mode\":0,\"hideprefix\":20,\"showcount\":true,\"namespaces\":false}","wgCentralAuthMobileDomain":false,"wgVisualEditorToolbarScrollOffset":0,"wgVisualEditorUnsupportedEditParams":["preload","preloadparams","preloadtitle","undo","undoafter","veswitched"],"wgEditSubmitButtonLabelPublish":true});mw.loader.state({"ext.gadget.Long-Image-Names-in-Categories":"ready","ext.globalCssJs.user.styles":"ready","ext.globalCssJs.site.styles":"ready","site.styles":"ready","noscript":"ready","user.styles":"ready","user":"ready","user.options":"loading","user.tokens":"loading","filepage":"ready","mediawiki.action.view.filepage":"ready","ext.visualEditor.desktopArticleTarget.noscript":"ready","ext.uls.pt":"ready","ext.wikimediaBadges":"ready","mediawiki.legacy.shared":"ready","mediawiki.legacy.commonPrint":"ready","mediawiki.sectionAnchor":"ready","mediawiki.skinning.interface":"ready","skins.vector.styles":"ready","ext.globalCssJs.user":"ready","ext.globalCssJs.site":"ready"});mw.loader.implement("user.options@0bhc5ha",function($,jQuery,require,module){mw.user.options.set([]);});mw.loader.implement("user.tokens@1dqfd7l",function ( $, jQuery, require, module ) {
mw.user.tokens.set({"editToken":"+\\","patrolToken":"+\\","watchToken":"+\\","csrfToken":"+\\"});/*@nomin*/

});mw.loader.load(["mediawiki.action.view.metadata","site","mediawiki.page.startup","mediawiki.user","mediawiki.hidpi","mediawiki.page.ready","mediawiki.searchSuggest","ext.gadget.Slideshow","ext.gadget.ZoomViewer","ext.gadget.CollapsibleTemplates","ext.gadget.fastcci","ext.gadget.UploadWizard","ext.gadget.Stockphoto","ext.gadget.WatchlistNotice","ext.gadget.AjaxQuickDelete","ext.gadget.WikiMiniAtlas","ext.gadget.LanguageSelect","ext.centralauth.centralautologin","mmv.head","mmv.bootstrap.autostart","ext.visualEditor.desktopArticleTarget.init","ext.visualEditor.targetLoader","ext.eventLogging.subscriber","ext.wikimediaEvents","ext.navigationTiming","ext.uls.eventlogger","ext.uls.init","ext.uls.interface","ext.centralNotice.geoIP","ext.centralNotice.startUp","skins.vector.js"]);});</script>
<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=ext.uls.pt%7Cext.visualEditor.desktopArticleTarget.noscript%7Cext.wikimediaBadges%7Cfilepage%7Cmediawiki.action.view.filepage%7Cmediawiki.legacy.commonPrint%2Cshared%7Cmediawiki.sectionAnchor%7Cmediawiki.skinning.interface%7Cskins.vector.styles&amp;only=styles&amp;skin=vector"/>
<script async="" src="/w/load.php?debug=false&amp;lang=en&amp;modules=startup&amp;only=scripts&amp;skin=vector"></script>
<meta name="ResourceLoaderDynamicStyles" content=""/>
<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=ext.gadget.Long-Image-Names-in-Categories&amp;only=styles&amp;skin=vector"/>
<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=site.styles&amp;only=styles&amp;skin=vector"/>
<noscript><link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=noscript&amp;only=styles&amp;skin=vector"/></noscript>
<meta name="generator" content="MediaWiki 1.30.0-wmf.17"/>
<meta name="referrer" content="origin-when-cross-origin"/>
<link rel="apple-touch-icon" href="/static/apple-touch/commons.png"/>
<link rel="shortcut icon" href="/static/favicon/commons.ico"/>
<link rel="search" type="application/opensearchdescription+xml" href="/w/opensearch_desc.php" title="Wikimedia Commons"/>
<link rel="EditURI" type="application/rsd+xml" href="//commons.wikimedia.org/w/api.php?action=rsd"/>
<link rel="license" href="//creativecommons.org/licenses/by-sa/3.0/"/>
<link rel="alternate" type="application/atom+xml" title="Wikimedia Commons Atom feed" href="/w/index.php?title=Special:RecentChanges&amp;feed=atom"/>
<link rel="canonical" href="https://commons.wikimedia.org/wiki/File:Flag_of_Syria.svg"/>
<link rel="dns-prefetch" href="//login.wikimedia.org"/>
<link rel="dns-prefetch" href="//meta.wikimedia.org" />
<!--[if lt IE 9]><script src="/resources/lib/html5shiv/html5shiv.min.js"></script><![endif]-->
</head>
<body class="mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-6 ns-subject page-File_Flag_of_Syria_svg rootpage-File_Flag_of_Syria_svg skin-vector action-view">		<div id="mw-page-base" class="noprint"></div>
		<div id="mw-head-base" class="noprint"></div>
		<div id="content" class="mw-body" role="main">
			<a id="top"></a>

							<div id="siteNotice" class="mw-body-content"><!-- CentralNotice --></div>
						<div class="mw-indicators mw-body-content">
</div>
			<h1 id="firstHeading" class="firstHeading" lang="en">File:Flag of Syria.svg</h1>
									<div id="bodyContent" class="mw-body-content">
									<div id="siteSub" class="noprint">From Wikimedia Commons, the free media repository</div>
								<div id="contentSub"></div>
												<div id="jump-to-nav" class="mw-jump">
					Jump to:					<a href="#mw-head">navigation</a>, 					<a href="#p-search">search</a>
				</div>
				<div id="mw-content-text"><ul id="filetoc"><li><a href="#file">File</a></li>
<li><a href="#filehistory">File history</a></li>
<li><a href="#filelinks">File usage on Commons</a></li>
<li><a href="#globalusage">File usage on other wikis</a></li>
<li><a href="#metadata">Metadata</a></li></ul><div class="fullImageLink" id="file"><a href="https://upload.wikimedia.org/wikipedia/commons/5/53/Flag_of_Syria.svg"><img alt="File:Flag of Syria.svg" src="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/800px-Flag_of_Syria.svg.png" width="800" height="533" srcset="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/1200px-Flag_of_Syria.svg.png 1.5x, https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/1599px-Flag_of_Syria.svg.png 2x" data-file-width="900" data-file-height="600" /></a><div class="mw-filepage-resolutioninfo">Size of this PNG preview of this SVG file: <a href="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/800px-Flag_of_Syria.svg.png" class="mw-thumbnail-link">800 × 533 pixels</a>. <span class="mw-filepage-other-resolutions">Other resolutions: <a href="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/320px-Flag_of_Syria.svg.png" class="mw-thumbnail-link">320 × 213 pixels</a> | <a href="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/640px-Flag_of_Syria.svg.png" class="mw-thumbnail-link">640 × 427 pixels</a> | <a href="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/1024px-Flag_of_Syria.svg.png" class="mw-thumbnail-link">1,024 × 683 pixels</a> | <a href="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/1280px-Flag_of_Syria.svg.png" class="mw-thumbnail-link">1,280 × 853 pixels</a> | <a href="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/900px-Flag_of_Syria.svg.png" class="mw-thumbnail-link">900 × 600 pixels</a>.</span></div></div>
<div class="fullMedia"><a href="https://upload.wikimedia.org/wikipedia/commons/5/53/Flag_of_Syria.svg" class="internal" title="Flag of Syria.svg">Original file</a> &#8206;<span class="fileInfo">(SVG file, nominally 900 × 600 pixels, file size: 656 bytes)</span>
</div>
<div id="mw-imagepage-content" lang="en" dir="ltr" class="mw-content-ltr"><div class="mw-parser-output"><h2><span class="mw-headline" id="Summary">Summary</span></h2>
<div class="hproduct commons-file-information-table">
<table class="fileinfotpl-type-information toccolours vevent mw-content-ltr" style="width: 100%; direction: ltr;" cellpadding="4">
<tr style="vertical-align: top">
<td id="fileinfotpl_desc" class="fileinfo-paramfield" lang="en" xml:lang="en">Description<span class="summary fn" style="display:none">Flag of Syria.svg</span></td>
<td class="description">
<div class="description mw-content-rtl ar" dir="rtl" lang="ar" style="" xml:lang="ar"><span class="language ar" title=""><b>العربية:</b></span> <a href="https://ar.wikipedia.org/wiki/%D8%B9%D9%84%D9%85_%D8%B3%D9%88%D8%B1%D9%8A%D8%A7" class="extiw" title="ar:علم سوريا">علم سوريا</a></div>
<div class="description mw-content-ltr ku" dir="ltr" lang="ku" style="" xml:lang="ku"><span class="language ku" title=""><b>Kurdî:</b></span> Alaya Sûriyê</div>
<div class="description mw-content-rtl arc" dir="rtl" lang="arc" style="" xml:lang="arc"><span class="language arc" title="Aramaic"><b>ܐܪܡܝܐ&#160;:</b></span> ܐܬܐ ܕ<a href="https://arc.wikipedia.org/wiki/%DC%A3%DC%98%DC%AA%DC%9D%DC%90" class="extiw" title="arc:ܣܘܪܝܐ">ܣܘܪܝܐ</a></div>
<div class="description mw-content-ltr de" dir="ltr" lang="de" style="" xml:lang="de"><span class="language de" title="Deutsch"><b>Deutsch:</b></span> <a href="https://de.wikipedia.org/wiki/Flagge_Syriens" class="extiw" title="de:Flagge Syriens">Flagge Syriens</a></div>
<div class="description mw-content-ltr en" dir="ltr" lang="en" style="" xml:lang="en"><span class="language en" title=""><b>English:</b></span> <a href="https://en.wikipedia.org/wiki/Flag_of_Syria" class="extiw" title="en:Flag of Syria">Flag of Syria</a></div>
<div class="description mw-content-ltr eo" dir="ltr" lang="eo" style="" xml:lang="eo"><span class="language eo" title=""><b>Esperanto:</b></span> Flago de <a href="https://eo.wikipedia.org/wiki/Sirio" class="extiw" title="eo:Sirio">Sirio</a></div>
<div class="description mw-content-ltr fr" dir="ltr" lang="fr" style="" xml:lang="fr"><span class="language fr" title="Français"><b>Français&#160;:</b></span> <a href="https://fr.wikipedia.org/wiki/Drapeau_de_la_Syrie" class="extiw" title="fr:Drapeau de la Syrie">Drapeau de la Syrie</a></div>
<div class="description mw-content-ltr ru" dir="ltr" lang="ru" style="" xml:lang="ru"><span class="language ru" title=""><b>Русский:</b></span> <a href="https://ru.wikipedia.org/wiki/%D0%A4%D0%BB%D0%B0%D0%B3_%D0%A1%D0%B8%D1%80%D0%B8%D0%B8" class="extiw" title="ru:Флаг Сирии">Флаг</a> <a href="https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D1%80%D0%B8%D1%8F" class="extiw" title="ru:Сирия">Сирии</a></div>
<div class="description mw-content-ltr sl" dir="ltr" lang="sl" style="" xml:lang="sl"><span class="language sl" title=""><b>Slovenščina:</b></span> Zastava <a href="https://sl.wikipedia.org/wiki/Sirija" class="extiw" title="sl:Sirija">Sirije</a></div>
<div class="description mw-content-ltr so" dir="ltr" lang="so" style="" xml:lang="so"><span class="language so" title=""><b>Soomaaliga:</b></span> Calanka <a href="https://so.wikipedia.org/wiki/Suuriya" class="extiw" title="so:Suuriya">Suuriya</a></div>
<div class="description mw-content-ltr tr" dir="ltr" lang="tr" style="" xml:lang="tr"><span class="language tr" title=""><b>Türkçe:</b></span> <a href="https://tr.wikipedia.org/wiki/Suriye_bayra%C4%9F%C4%B1" class="extiw" title="tr:Suriye bayrağı">Suriye bayrağı</a></div>
<div class="description mw-content-ltr uk" dir="ltr" lang="uk" style="" xml:lang="uk"><span class="language uk" title=""><b>Українська:</b></span> <a href="https://uk.wikipedia.org/wiki/%D0%9F%D1%80%D0%B0%D0%BF%D0%BE%D1%80_%D0%A1%D0%B8%D1%80%D1%96%D1%97" class="extiw" title="uk:Прапор Сирії">Прапор Сирії</a></div>
</td>
</tr>
<tr style="vertical-align: top">
<td id="fileinfotpl_date" class="fileinfo-paramfield" lang="en" xml:lang="en">Date</td>
<td lang="en" xml:lang="en"></td>
</tr>
<tr style="vertical-align: top">
<td id="fileinfotpl_src" class="fileinfo-paramfield" lang="en" xml:lang="en">Source</td>
<td>see below</td>
</tr>
<tr style="vertical-align: top">
<td id="fileinfotpl_aut" class="fileinfo-paramfield" lang="en" xml:lang="en">Author</td>
<td>see below</td>
</tr>
<tr style="vertical-align: top">
<td id="fileinfotpl_ver" class="fileinfo-paramfield" lang="en" xml:lang="en">Other versions</td>
<td>
<p>Derivative works of this file:&#160;<a href="/wiki/File:Syrian_Air_Force_Ensign.svg" class="mw-redirect" title="File:Syrian Air Force Ensign.svg">Syrian Air Force Ensign.svg</a></p>
</td>
</tr>
<tr valign="top">
<td style="" class="fileinfo-paramfield">SVG&#160;development</td>
<td style="">
<div lang="en" class="mw-content-ltr plainlinks" xml:lang="en">
<div class="mw-content-ltr">
<table cellspacing="0" style="color:#000;background:#DDD;border:1px solid #BBB;margin:.1em;width:;background:#EEE;float:left" class="createdwithtemplate layouttemplate">
<tr>
<td style="width:1.2em;height:1.2em;padding:.2em;background:#CE8">
<div class="center">
<div class="floatnone"><a href="//validator.w3.org/" rel="nofollow"><img alt="W3C icon.svg" src="https://upload.wikimedia.org/wikipedia/commons/thumb/5/5e/W3C_icon.svg/24px-W3C_icon.svg.png" width="24" height="13" srcset="https://upload.wikimedia.org/wikipedia/commons/thumb/5/5e/W3C_icon.svg/36px-W3C_icon.svg.png 1.5x, https://upload.wikimedia.org/wikipedia/commons/thumb/5/5e/W3C_icon.svg/48px-W3C_icon.svg.png 2x" data-file-width="212" data-file-height="114" /></a></div>
</div>
</td>
<td style="font-size:.85em;padding:.2em;vertical-align:middle;">The source code of this <a href="/wiki/Help:SVG" title="Help:SVG">SVG</a> is <a rel="nofollow" class="external text" href="//validator.w3.org/check?uri=https%3A%2F%2Fcommons.wikimedia.org%2Fwiki%2FSpecial%3AFilepath%2FFlag_of_Syria.svg&amp;ss=1#source"><span style="background:#CE8">valid</span></a>.</td>
</tr>
</table>
</div>
</div>
<div class="mw-content-ltr">
<table cellspacing="0" style="color:#000;background:#DDD;border:1px solid #BBB;margin:.1em;width:;float:left;height:1.2em;vertical-align:middle" class="createdwithtemplate layouttemplate">
<tr>
<td style="width:1.2em;height:1.2em;padding:.2em;">
<div class="center">
<div class="floatnone"><a href="/wiki/File:UnknownTool_logo.svg" title="File:UnknownTool logo.svg"><img alt="UnknownTool logo.svg" src="https://upload.wikimedia.org/wikipedia/commons/thumb/8/8b/UnknownTool_logo.svg/20px-UnknownTool_logo.svg.png" width="20" height="20" srcset="https://upload.wikimedia.org/wikipedia/commons/thumb/8/8b/UnknownTool_logo.svg/30px-UnknownTool_logo.svg.png 1.5x, https://upload.wikimedia.org/wikipedia/commons/thumb/8/8b/UnknownTool_logo.svg/40px-UnknownTool_logo.svg.png 2x" data-file-width="512" data-file-height="512" /></a></div>
</div>
</td>
<td style="font-size:.85em;padding:.2em;vertical-align:middle;">This flag was created with an unknown SVG editor or tool.</td>
</tr>
</table>
</div>
</td>
</tr>
</table>
</div>
<h2><span class="mw-headline" id="Licensing">Licensing</span></h2>
<table class="licensetpl" style="display:none">
<tr>
<td><span class="licensetpl_short">Public domain</span><span class="licensetpl_long">Public domain</span><span class="licensetpl_link_req">false</span><span class="licensetpl_attr_req">false</span></td>
</tr>
</table>
<table style="width:100%; clear:both; margin:0.5em auto; background-color:#f7f8ff; border:2px solid #8888aa; direction: ltr; border-spacing: 8px; padding: 0px;" class="layouttemplate mw-content-ltr" lang="en" xml:lang="en">
<tr>
<td><img alt="Public domain" src="https://upload.wikimedia.org/wikipedia/commons/thumb/6/62/PD-icon.svg/64px-PD-icon.svg.png" title="Public domain" width="64" height="64" srcset="https://upload.wikimedia.org/wikipedia/commons/thumb/6/62/PD-icon.svg/96px-PD-icon.svg.png 1.5x, https://upload.wikimedia.org/wikipedia/commons/thumb/6/62/PD-icon.svg/128px-PD-icon.svg.png 2x" data-file-width="196" data-file-height="196" /></td>
<td>I, the copyright holder of this work, release this work into the <b><a href="https://en.wikipedia.org/wiki/en:public_domain" class="extiw" title="w:en:public domain">public domain</a></b>. This applies worldwide.<br />
<small>In some countries this may not be legally possible; if so:</small><br />
<i>I grant anyone the right to use this work <b>for any purpose</b>, without any conditions, unless such conditions are required by law.</i>
<p><span class="licensetpl_short" style="display:none;">Public domain</span><span class="licensetpl_long" style="display:none;">Public domain</span><span class="licensetpl_link_req" style="display:none;">false</span><span class="licensetpl_attr_req" style="display:none;">false</span></p>
</td>
</tr>
</table>


<!-- 
NewPP limit report
Parsed by mw1238
Cached time: 20170909191129
Cache expiry: 1900800
Dynamic content: false
CPU time usage: 0.164 seconds
Real time usage: 0.232 seconds
Preprocessor visited node count: 3707/1000000
Preprocessor generated node count: 0/1500000
Post‐expand include size: 34211/2097152 bytes
Template argument size: 13195/2097152 bytes
Highest expansion depth: 26/40
Expensive parser function count: 7/500
Lua time usage: 0.030/10.000 seconds
Lua memory usage: 1.55 MB/50 MB
-->
<!--
Transclusion expansion time report (%,ms,calls,template)
100.00%  210.053      1 -total
 96.33%  202.351      1 Template:Information
 47.64%  100.079      1 Template:Igen
 38.89%   81.688      1 Template:InFi
 24.50%   51.465      1 Template:Created_with_Unknown_tool
 11.97%   25.137      2 Template:Autotranslate
 10.95%   22.995      1 Template:SVGvalid
 10.71%   22.507      1 Template:DerivativeVersions
 10.13%   21.272      1 Template:ISOdate
  9.52%   20.004      2 Template:Created_with
-->
</div>
<!-- Saved in parser cache with key commonswiki:pcache:idhash:363156-0!canonical and timestamp 20170909191128 and revision id 210166516
 -->
</div><h2 id="filehistory">File history</h2>
<div id="mw-imagepage-section-filehistory">
<p>Click on a date/time to view the file as it appeared at that time.
</p>(newest | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;dir=prev#filehistory" class="mw-lastlink" title="File:Flag of Syria.svg">oldest</a>) View (newer 10 | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=20130701155534#filehistory" class="mw-nextlink" title="File:Flag of Syria.svg" rel="next">older 10</a>) (<a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=10#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">10</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=20#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">20</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=50#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">50</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=100#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">100</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=250#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">250</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=500#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">500</a>)
<table class="wikitable filehistory">
<tr><th></th><th>Date/Time</th><th>Thumbnail</th><th>Dimensions</th><th>User</th><th>Comment</th></tr>
<tr><td>current</td><td class='filehistory-selected' style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/5/53/Flag_of_Syria.svg">20:23, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/5/53/Flag_of_Syria.svg"><img alt="Thumbnail for version as of 20:23, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/5/53/Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(656 bytes)</span></td><td><a href="/wiki/User:INeverCry" class="mw-userlink" title="User:INeverCry"><bdi>INeverCry</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:INeverCry" class="mw-usertoollinks-talk" title="User talk:INeverCry">talk</a> | <a href="/wiki/Special:Contributions/INeverCry" class="mw-usertoollinks-contribs" title="Special:Contributions/INeverCry">contribs</a>)</span></span></td><td dir="ltr">Reverted to version as of 19:26, 1 July 2013</td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701202343%21Flag_of_Syria.svg">19:29, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701202343%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 19:29, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701202343%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(573 bytes)</span></td><td><a href="/w/index.php?title=User:Mohammed_alkhater&amp;action=edit&amp;redlink=1" class="new mw-userlink" title="User:Mohammed alkhater (page does not exist)"><bdi>Mohammed alkhater</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Mohammed_alkhater" class="mw-usertoollinks-talk" title="User talk:Mohammed alkhater">talk</a> | <a href="/wiki/Special:Contributions/Mohammed_alkhater" class="mw-usertoollinks-contribs" title="Special:Contributions/Mohammed alkhater">contribs</a>)</span></span></td><td dir="ltr">Reverted to version as of 19:23, 1 July 2013</td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701192938%21Flag_of_Syria.svg">19:26, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701192938%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 19:26, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701192938%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(656 bytes)</span></td><td><a href="/wiki/User:Fry1989" class="mw-userlink" title="User:Fry1989"><bdi>Fry1989</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Fry1989" class="mw-usertoollinks-talk" title="User talk:Fry1989">talk</a> | <a href="/wiki/Special:Contributions/Fry1989" class="mw-usertoollinks-contribs" title="Special:Contributions/Fry1989">contribs</a>)</span></span></td><td dir="ltr">Reverted to version as of 19:01, 1 July 2013</td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701192623%21Flag_of_Syria.svg">19:23, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701192623%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 19:23, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701192623%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(573 bytes)</span></td><td><a href="/w/index.php?title=User:Mohammed_alkhater&amp;action=edit&amp;redlink=1" class="new mw-userlink" title="User:Mohammed alkhater (page does not exist)"><bdi>Mohammed alkhater</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Mohammed_alkhater" class="mw-usertoollinks-talk" title="User talk:Mohammed alkhater">talk</a> | <a href="/wiki/Special:Contributions/Mohammed_alkhater" class="mw-usertoollinks-contribs" title="Special:Contributions/Mohammed alkhater">contribs</a>)</span></span></td><td dir="ltr">Reverted to version as of 18:55, 1 July 2013</td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701192342%21Flag_of_Syria.svg">19:01, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701192342%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 19:01, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701192342%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(656 bytes)</span></td><td><a href="/wiki/User:Fry1989" class="mw-userlink" title="User:Fry1989"><bdi>Fry1989</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Fry1989" class="mw-usertoollinks-talk" title="User talk:Fry1989">talk</a> | <a href="/wiki/Special:Contributions/Fry1989" class="mw-usertoollinks-contribs" title="Special:Contributions/Fry1989">contribs</a>)</span></span></td><td dir="ltr"></td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701190110%21Flag_of_Syria.svg">18:55, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701190110%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 18:55, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701190110%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(573 bytes)</span></td><td><a href="/w/index.php?title=User:Mohammed_alkhater&amp;action=edit&amp;redlink=1" class="new mw-userlink" title="User:Mohammed alkhater (page does not exist)"><bdi>Mohammed alkhater</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Mohammed_alkhater" class="mw-usertoollinks-talk" title="User talk:Mohammed alkhater">talk</a> | <a href="/wiki/Special:Contributions/Mohammed_alkhater" class="mw-usertoollinks-contribs" title="Special:Contributions/Mohammed alkhater">contribs</a>)</span></span></td><td dir="ltr">Reverted to version as of 18:44, 1 July 2013</td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701185500%21Flag_of_Syria.svg">18:52, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701185500%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 18:52, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701185500%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(656 bytes)</span></td><td><a href="/wiki/User:Fry1989" class="mw-userlink" title="User:Fry1989"><bdi>Fry1989</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Fry1989" class="mw-usertoollinks-talk" title="User talk:Fry1989">talk</a> | <a href="/wiki/Special:Contributions/Fry1989" class="mw-usertoollinks-contribs" title="Special:Contributions/Fry1989">contribs</a>)</span></span></td><td dir="ltr">vandalism</td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701185202%21Flag_of_Syria.svg">18:44, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701185202%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 18:44, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701185202%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(573 bytes)</span></td><td><a href="/w/index.php?title=User:Mohammed_alkhater&amp;action=edit&amp;redlink=1" class="new mw-userlink" title="User:Mohammed alkhater (page does not exist)"><bdi>Mohammed alkhater</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Mohammed_alkhater" class="mw-usertoollinks-talk" title="User talk:Mohammed alkhater">talk</a> | <a href="/wiki/Special:Contributions/Mohammed_alkhater" class="mw-usertoollinks-contribs" title="Special:Contributions/Mohammed alkhater">contribs</a>)</span></span></td><td dir="ltr">Reverted to version as of 11:55, 1 July 2013</td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701184452%21Flag_of_Syria.svg">18:44, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701184452%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 18:44, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701184452%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(573 bytes)</span></td><td><a href="/w/index.php?title=User:Mohammed_alkhater&amp;action=edit&amp;redlink=1" class="new mw-userlink" title="User:Mohammed alkhater (page does not exist)"><bdi>Mohammed alkhater</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Mohammed_alkhater" class="mw-usertoollinks-talk" title="User talk:Mohammed alkhater">talk</a> | <a href="/wiki/Special:Contributions/Mohammed_alkhater" class="mw-usertoollinks-contribs" title="Special:Contributions/Mohammed alkhater">contribs</a>)</span></span></td><td dir="ltr">Reverted to version as of 11:55, 1 July 2013</td></tr>
<tr><td></td><td  style='white-space: nowrap;'><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701184402%21Flag_of_Syria.svg">15:55, 1 July 2013</a></td><td><a href="https://upload.wikimedia.org/wikipedia/commons/archive/5/53/20130701184402%21Flag_of_Syria.svg"><img alt="Thumbnail for version as of 15:55, 1 July 2013" src="https://upload.wikimedia.org/wikipedia/commons/thumb/archive/5/53/20130701184402%21Flag_of_Syria.svg/120px-Flag_of_Syria.svg.png" width="120" height="80" data-file-width="900" data-file-height="600" /></a></td><td>900 × 600 <span style="white-space: nowrap;">(656 bytes)</span></td><td><a href="/wiki/User:Fry1989" class="mw-userlink" title="User:Fry1989"><bdi>Fry1989</bdi></a><span style="white-space: nowrap;"> <span class="mw-usertoollinks">(<a href="/wiki/User_talk:Fry1989" class="mw-usertoollinks-talk" title="User talk:Fry1989">talk</a> | <a href="/wiki/Special:Contributions/Fry1989" class="mw-usertoollinks-contribs" title="Special:Contributions/Fry1989">contribs</a>)</span></span></td><td dir="ltr">vandalism</td></tr>
</table>
(newest | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;dir=prev#filehistory" class="mw-lastlink" title="File:Flag of Syria.svg">oldest</a>) View (newer 10 | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=20130701155534#filehistory" class="mw-nextlink" title="File:Flag of Syria.svg" rel="next">older 10</a>) (<a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=10#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">10</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=20#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">20</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=50#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">50</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=100#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">100</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=250#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">250</a> | <a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;offset=&amp;limit=500#filehistory" class="mw-numlink" title="File:Flag of Syria.svg">500</a>)
</div>
<ul>
<li id="mw-imagepage-upload-disallowed">You cannot overwrite this file.</li>
</ul>
<h2 id="filelinks">File usage on Commons</h2>
<div id='mw-imagepage-section-linkstoimage'>
<p>More than 100 pages link to this file.
The following list shows the first 100 page links to this file only.
A <a href="/wiki/Special:WhatLinksHere/File:Flag_of_Syria.svg" title="Special:WhatLinksHere/File:Flag of Syria.svg">full list</a> is available.
</p><ul class="mw-imagepage-linkstoimage">
<li class="mw-imagepage-linkstoimage-ns0"><a href="/wiki/Atlas_of_Syria" title="Atlas of Syria">Atlas of Syria</a></li>
<li class="mw-imagepage-linkstoimage-ns0"><a href="/wiki/Country_flags_history" title="Country flags history">Country flags history</a></li>
<li class="mw-imagepage-linkstoimage-ns0"><a href="/wiki/Flags_with_stars" title="Flags with stars">Flags with stars</a></li>
<li class="mw-imagepage-linkstoimage-ns0"><a href="/wiki/Maritime_flags" title="Maritime flags">Maritime flags</a></li>
<li class="mw-imagepage-linkstoimage-ns0"><a href="/wiki/National_insignia" title="National insignia">National insignia</a></li>
<li class="mw-imagepage-linkstoimage-ns0"><a href="/wiki/Police_cars_by_country" title="Police cars by country">Police cars by country</a></li>
<li class="mw-imagepage-linkstoimage-ns0"><a href="/wiki/Sovereign-state_flags" title="Sovereign-state flags">Sovereign-state flags</a></li>
<li class="mw-imagepage-linkstoimage-ns2"><a href="/wiki/User:Bgag" title="User:Bgag">User:Bgag</a></li>
<li class="mw-imagepage-linkstoimage-ns2"><a href="/wiki/User:Caetano_77" title="User:Caetano 77">User:Caetano 77</a></li>
<li class="mw-imagepage-linkstoimage-ns2"><a href="/wiki/User:Flag_Dude~commonswiki" title="User:Flag Dude~commonswiki">User:Flag Dude~commonswiki</a></li>
<li class="mw-imagepage-linkstoimage-ns2"><a href="/wiki/User:Krokodyl" title="User:Krokodyl">User:Krokodyl</a></li>
<li class="mw-imagepage-linkstoimage-ns2"><a href="/wiki/User:Moroder" title="User:Moroder">User:Moroder</a></li>
<li class="mw-imagepage-linkstoimage-ns2"><a href="/wiki/User:Qasamaan~commonswiki" title="User:Qasamaan~commonswiki">User:Qasamaan~commonswiki</a></li>
<li class="mw-imagepage-linkstoimage-ns2"><a href="/wiki/User:Sojah" title="User:Sojah">User:Sojah</a></li>
<li class="mw-imagepage-linkstoimage-ns2"><a href="/wiki/User:Yann" title="User:Yann">User:Yann</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:030Arab.jpg" title="File:030Arab.jpg">File:030Arab.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:22_alphabet.jpg" title="File:22 alphabet.jpg">File:22 alphabet.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:ALEPPO_STATE_OFFICIAL_DOCUMENT.jpg" title="File:ALEPPO STATE OFFICIAL DOCUMENT.jpg">File:ALEPPO STATE OFFICIAL DOCUMENT.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Abdul_Hamid_Sarraj.jpg" title="File:Abdul Hamid Sarraj.jpg">File:Abdul Hamid Sarraj.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Ahmed_al-Khatib.jpg" title="File:Ahmed al-Khatib.jpg">File:Ahmed al-Khatib.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Al_Assad_family.jpg" title="File:Al Assad family.jpg">File:Al Assad family.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Al_Hasani_Nakkash_1941.jpg" title="File:Al Hasani Nakkash 1941.jpg">File:Al Hasani Nakkash 1941.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Alawite_men.jpg" title="File:Alawite men.jpg">File:Alawite men.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Alawiteman.jpg" title="File:Alawiteman.jpg">File:Alawiteman.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Aleppo-Jewish201914.jpg" title="File:Aleppo-Jewish201914.jpg">File:Aleppo-Jewish201914.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Aleppo-Music0Band.jpg" title="File:Aleppo-Music0Band.jpg">File:Aleppo-Music0Band.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:AleppoCafeWaterpipe.jpg" title="File:AleppoCafeWaterpipe.jpg">File:AleppoCafeWaterpipe.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:AleppoEmirMudhem.jpg" title="File:AleppoEmirMudhem.jpg">File:AleppoEmirMudhem.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Aleppo_Central_Synagogue.jpeg" title="File:Aleppo Central Synagogue.jpeg">File:Aleppo Central Synagogue.jpeg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Aleppomusic.jpg" title="File:Aleppomusic.jpg">File:Aleppomusic.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Alepporabbiwithsecretary.jpg" title="File:Alepporabbiwithsecretary.jpg">File:Alepporabbiwithsecretary.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Arafat_Darwish_Habash.jpg" title="File:Arafat Darwish Habash.jpg">File:Arafat Darwish Habash.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Armenian_child_refugees_(Aleppo,_Syria,_1915).jpg" title="File:Armenian child refugees (Aleppo, Syria, 1915).jpg">File:Armenian child refugees (Aleppo, Syria, 1915).jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Asmahan.jpg" title="File:Asmahan.jpg">File:Asmahan.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Atassi_2nd_inauguration_Dec_1949.jpg" title="File:Atassi 2nd inauguration Dec 1949.jpg">File:Atassi 2nd inauguration Dec 1949.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Barada2.jpg" title="File:Barada2.jpg">File:Barada2.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Basil_al-Assad.jpg" title="File:Basil al-Assad.jpg">File:Basil al-Assad.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Basil_assad.JPG" title="File:Basil assad.JPG">File:Basil assad.JPG</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Bedouincoffeecup.jpg" title="File:Bedouincoffeecup.jpg">File:Bedouincoffeecup.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Circassiantroopswiththeirfrenchofficer.jpg" title="File:Circassiantroopswiththeirfrenchofficer.jpg">File:Circassiantroopswiththeirfrenchofficer.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Colonialreplycoupons1930s-1950s.jpg" title="File:Colonialreplycoupons1930s-1950s.jpg">File:Colonialreplycoupons1930s-1950s.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:DamasChristianQuarter1860.jpg" title="File:DamasChristianQuarter1860.jpg">File:DamasChristianQuarter1860.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:DamascusSyrianBreadseller.jpg" title="File:DamascusSyrianBreadseller.jpg">File:DamascusSyrianBreadseller.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:DamascusabdulKader.jpg" title="File:DamascusabdulKader.jpg">File:DamascusabdulKader.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Druze_warriors.jpg" title="File:Druze warriors.jpg">File:Druze warriors.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Druzeindependance1925.jpg" title="File:Druzeindependance1925.jpg">File:Druzeindependance1925.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Duraid_Lahham.jpg" title="File:Duraid Lahham.jpg">File:Duraid Lahham.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Eli_Cohen.jpg" title="File:Eli Cohen.jpg">File:Eli Cohen.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Emir_Abdelkader1965.JPG" title="File:Emir Abdelkader1965.JPG">File:Emir Abdelkader1965.JPG</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:FamArabs.jpg" title="File:FamArabs.jpg">File:FamArabs.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Faris_al-Khoury.jpg" title="File:Faris al-Khoury.jpg">File:Faris al-Khoury.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Fatrash.JPG" title="File:Fatrash.JPG">File:Fatrash.JPG</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Flag_of_Syria.png" title="File:Flag of Syria.png">File:Flag of Syria.png</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Flag_of_Syria_(WFB_2004).gif" title="File:Flag of Syria (WFB 2004).gif">File:Flag of Syria (WFB 2004).gif</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:General_Hafez_al-Assad_in_1970,_during_the_Syrian_Corrective_Revolution.jpg" title="File:General Hafez al-Assad in 1970, during the Syrian Corrective Revolution.jpg">File:General Hafez al-Assad in 1970, during the Syrian Corrective Revolution.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Hafezalassad.jpg" title="File:Hafezalassad.jpg">File:Hafezalassad.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Hashim_Al_Atassi.jpg" title="File:Hashim Al Atassi.jpg">File:Hashim Al Atassi.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Hashim_Atassi_Inauguration_1936.jpg" title="File:Hashim Atassi Inauguration 1936.jpg">File:Hashim Atassi Inauguration 1936.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Homs.jpg" title="File:Homs.jpg">File:Homs.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Husni_al-Zaiim.jpg" title="File:Husni al-Zaiim.jpg">File:Husni al-Zaiim.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Ignatius_Gabriel_I_Tappouni.gif" title="File:Ignatius Gabriel I Tappouni.gif">File:Ignatius Gabriel I Tappouni.gif</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Jewish_family_in_Damascus,_1910.jpg" title="File:Jewish family in Damascus, 1910.jpg">File:Jewish family in Damascus, 1910.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Jewish_wedding.jpg" title="File:Jewish wedding.jpg">File:Jewish wedding.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Man_see_school_nakba.jpg" title="File:Man see school nakba.jpg">File:Man see school nakba.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:MapAleppo_1912.jpg" title="File:MapAleppo 1912.jpg">File:MapAleppo 1912.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:MapAleppo_1912a.jpg" title="File:MapAleppo 1912a.jpg">File:MapAleppo 1912a.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Nizar_Kabbani_-_1935.jpg" title="File:Nizar Kabbani - 1935.jpg">File:Nizar Kabbani - 1935.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Nizar_Kabbani_-_1936.jpg" title="File:Nizar Kabbani - 1936.jpg">File:Nizar Kabbani - 1936.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Nizar_Kabbani_-_1944.jpg" title="File:Nizar Kabbani - 1944.jpg">File:Nizar Kabbani - 1944.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Nizar_Kabbani_-_1948.jpg" title="File:Nizar Kabbani - 1948.jpg">File:Nizar Kabbani - 1948.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:PalmyraAncientAvenue.JPG" title="File:PalmyraAncientAvenue.JPG">File:PalmyraAncientAvenue.JPG</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Palmyrasheikh.jpg" title="File:Palmyrasheikh.jpg">File:Palmyrasheikh.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Proclamation_of_King_Faisal_I_as_King_of_Syria.jpg" title="File:Proclamation of King Faisal I as King of Syria.jpg">File:Proclamation of King Faisal I as King of Syria.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Qishani.jpg" title="File:Qishani.jpg">File:Qishani.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Rabbiandofficialsofaleppogreatsynagogue.jpg" title="File:Rabbiandofficialsofaleppogreatsynagogue.jpg">File:Rabbiandofficialsofaleppogreatsynagogue.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Rifaathafezassad.jpg" title="File:Rifaathafezassad.jpg">File:Rifaathafezassad.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:SYRIAN_25_PIASTRES_1919.jpg" title="File:SYRIAN 25 PIASTRES 1919.jpg">File:SYRIAN 25 PIASTRES 1919.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Sah_ennoam.jpg" title="File:Sah ennoam.jpg">File:Sah ennoam.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Saladin_and_Guy.jpg" title="File:Saladin and Guy.jpg">File:Saladin and Guy.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Salma_el-Masri.jpg" title="File:Salma el-Masri.jpg">File:Salma el-Masri.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Sami_al-Hinnawi.jpg" title="File:Sami al-Hinnawi.jpg">File:Sami al-Hinnawi.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Sharif_Husayn.jpg" title="File:Sharif Husayn.jpg">File:Sharif Husayn.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Shishakli.jpg" title="File:Shishakli.jpg">File:Shishakli.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Signataires_de_la_Convention_internationale_sur_la_protection_des_droits_de_tous_les_travailleurs_migrants_et_des_membres_de_leur_famille.PNG" title="File:Signataires de la Convention internationale sur la protection des droits de tous les travailleurs migrants et des membres de leur famille.PNG">File:Signataires de la Convention internationale sur la protection des droits de tous les travailleurs migrants et des membres de leur famille.PNG</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Stamp_Alexandretta_4pi.jpg" title="File:Stamp Alexandretta 4pi.jpg">File:Stamp Alexandretta 4pi.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Sultan_Pasha_al-Atrash.jpg" title="File:Sultan Pasha al-Atrash.jpg">File:Sultan Pasha al-Atrash.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Sultan_al-Atrash.jpg" title="File:Sultan al-Atrash.jpg">File:Sultan al-Atrash.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:SyrianDouroze.jpg" title="File:SyrianDouroze.jpg">File:SyrianDouroze.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Syrian_SAM.jpg" title="File:Syrian SAM.jpg">File:Syrian SAM.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Syriancafe.jpg" title="File:Syriancafe.jpg">File:Syriancafe.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Syriancorpse.jpg" title="File:Syriancorpse.jpg">File:Syriancorpse.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Weizmann_and_feisal_1918.jpg" title="File:Weizmann and feisal 1918.jpg">File:Weizmann and feisal 1918.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Winston_Churchill,_British_Colonial_Secretary_1912.jpg" title="File:Winston Churchill, British Colonial Secretary 1912.jpg">File:Winston Churchill, British Colonial Secretary 1912.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:Woodworkdamas.JPG" title="File:Woodworkdamas.JPG">File:Woodworkdamas.JPG</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:%D8%A8%D8%AF%D9%88%D9%8A-%D8%A7%D9%84%D8%AC%D8%A8%D9%84-badawi-aljabal.jpg" title="File:بدوي-الجبل-badawi-aljabal.jpg">File:بدوي-الجبل-badawi-aljabal.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns6"><a href="/wiki/File:%E2%80%99Mohamed_alhamed.jpg" title="File:’Mohamed alhamed.jpg">File:’Mohamed alhamed.jpg</a></li>
<li class="mw-imagepage-linkstoimage-ns7"><a href="/wiki/File_talk:Flag_of_Portugal.svg" title="File talk:Flag of Portugal.svg">File talk:Flag of Portugal.svg</a></li>
<li class="mw-imagepage-linkstoimage-ns7"><a href="/wiki/File_talk:International_reaction_to_the_2008%E2%80%932009_Israel%E2%80%93Gaza_conflict.png" title="File talk:International reaction to the 2008–2009 Israel–Gaza conflict.png">File talk:International reaction to the 2008–2009 Israel–Gaza conflict.png</a></li>
<li class="mw-imagepage-linkstoimage-ns10"><a href="/wiki/Template:PD-Syria" title="Template:PD-Syria">Template:PD-Syria</a></li>
<li class="mw-imagepage-linkstoimage-ns11"><a href="/wiki/Template_talk:Assessments/Archive_1" title="Template talk:Assessments/Archive 1">Template talk:Assessments/Archive 1</a></li>
</ul>
</div>
<h2 id="globalusage">File usage on other wikis</h2>
<div id="mw-imagepage-section-globalusage"><p>The following other wikis use this file:
</p><ul>
<li class='mw-gu-onwiki-ab_wikipedia_org'>Usage on ab.wikipedia.org
<ul>	<li><a class="external" href="//ab.wikipedia.org/wiki/%D0%90%D1%82%D3%99%D1%8B%D0%BB%D0%B0%D2%9B%D3%99%D0%B5%D0%B8_%D0%B0%D1%82%D0%B5%D1%80%D1%80%D0%B8%D1%82%D0%BE%D1%80%D0%B8%D0%B0%D2%9B%D3%99%D0%B5%D0%B8_%D0%B0%D0%BB%D1%84%D0%B0%D0%B2%D0%B8%D1%82%D1%82%D3%99_%D1%80%D1%8B%D1%85%D1%8C%D3%A1%D1%8B%D0%BD%D2%B5%D0%B0">Атәылақәеи атерриториақәеи алфавиттә рыхьӡынҵа</a></li>
	<li><a class="external" href="//ab.wikipedia.org/wiki/%D0%90%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD:%D0%90%D0%B1%D1%8B%D1%80%D0%B0%D2%9F%D0%B4%D1%8B%D1%80%D0%B3%D0%B0/%D0%A8%D1%8C%D0%B0%D0%BC%D1%82%D3%99%D1%8B%D0%BB%D0%B0">Ашаблон:Абыраҟдырга/Шьамтәыла</a></li>
</ul></li>
<li class='mw-gu-onwiki-ace_wikipedia_org'>Usage on ace.wikipedia.org
<ul>	<li><a class="external" href="//ace.wikipedia.org/wiki/Afghanistan">Afghanistan</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Arab_Saudi">Arab Saudi</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Asia">Asia</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Bahrain">Bahrain</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Irak">Irak</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Kuwait">Kuwait</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Oman">Oman</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Pal%C3%A8stina">Palèstina</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Qatar">Qatar</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Siprus">Siprus</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Suriyah">Suriyah</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Turuki">Turuki</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Imarat_Arab_Meusaboh">Imarat Arab Meusaboh</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Yaman">Yaman</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Yordania">Yordania</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Lubnan">Lubnan</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Isra%C3%A8l">Israèl</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Iran">Iran</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Pola:Infobox_neugara_suriyah">Pola:Infobox neugara suriyah</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Seunaleu%C3%ABk:Country_data_Suriyah">Seunaleuëk:Country data Suriyah</a></li>
	<li><a class="external" href="//ace.wikipedia.org/wiki/Seunaleu%C3%ABk:Asia_Barat">Seunaleuëk:Asia Barat</a></li>
</ul></li>
<li class='mw-gu-onwiki-ady_wikipedia_org'>Usage on ady.wikipedia.org
<ul>	<li><a class="external" href="//ady.wikipedia.org/wiki/Category:%D0%A1%D0%B8%D1%80%D0%B8%D0%B5">Category:Сирие</a></li>
</ul></li>
<li class='mw-gu-onwiki-af_wikipedia_org'>Usage on af.wikipedia.org
<ul>	<li><a class="external" href="//af.wikipedia.org/wiki/Asi%C3%AB">Asië</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Arabies">Arabies</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_olieproduserende_state">Lys van olieproduserende state</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Moslem">Moslem</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_lande_volgens_bevolking">Lys van lande volgens bevolking</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/S%C3%A3o_Paulo">São Paulo</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Siri%C3%AB">Sirië</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Turkye">Turkye</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Kamov_Ka-27">Kamov Ka-27</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_lande_volgens_bevolkingsdigtheid">Lys van lande volgens bevolkingsdigtheid</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Geallieerdes_van_die_Tweede_W%C3%AAreldoorlog">Geallieerdes van die Tweede Wêreldoorlog</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_lande">Lys van lande</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Droese">Droese</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_lande_volgens_Menslike_Ontwikkelingsindeks">Lys van lande volgens Menslike Ontwikkelingsindeks</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Sjabloon:Landdata_Siri%C3%AB">Sjabloon:Landdata Sirië</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_lande_volgens_BBP_(nominaal)_per_capita">Lys van lande volgens BBP (nominaal) per capita</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_lande_volgens_BBP_(koopkragpariteit)_per_capita">Lys van lande volgens BBP (koopkragpariteit) per capita</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_lande_volgens_oppervlak">Lys van lande volgens oppervlak</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Lys_van_lande_volgens_geletterdheidskoers">Lys van lande volgens geletterdheidskoers</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Pous_Sergius_I">Pous Sergius I</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Damaskus">Damaskus</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Kategorie:Siri%C3%AB">Kategorie:Sirië</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Olimpiese_Somerspele_2008">Olimpiese Somerspele 2008</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Olimpiese_Somerspele_2012">Olimpiese Somerspele 2012</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Olimpiese_Somerspele_2004">Olimpiese Somerspele 2004</a></li>
	<li><a class="external" href="//af.wikipedia.org/wiki/Istanboel">Istanboel</a></li>
</ul></li>
</ul>
<p>View <a href="/wiki/Special:GlobalUsage/Flag_of_Syria.svg" title="Special:GlobalUsage/Flag of Syria.svg">more global usage</a> of this file.
</p></div><h2 id="metadata">Metadata</h2>
<div class="mw-imagepage-section-metadata">This file contains additional information such as Exif metadata which may have been added by the digital camera, scanner, or software program used to create or digitize it. If the file has been modified from its original state, some details such as the timestamp may not fully reflect those of the original file. The timestamp is only as accurate as the clock in the camera, and it may be completely wrong.<table id="mw_metadata" class="mw_metadata">
<tr class="exif-imagewidth collapsable"><th>Width</th><td>900</td></tr><tr class="exif-imagelength collapsable"><th>Height</th><td>600</td></tr></table>
</div>
<noscript><img src="//commons.wikimedia.org/wiki/Special:CentralAutoLogin/start?type=1x1" alt="" title="" width="1" height="1" style="border: none; position: absolute;" /></noscript></div>					<div class="printfooter">
						Retrieved from "<a dir="ltr" href="https://commons.wikimedia.org/w/index.php?title=File:Flag_of_Syria.svg&amp;oldid=210166516">https://commons.wikimedia.org/w/index.php?title=File:Flag_of_Syria.svg&amp;oldid=210166516</a>"					</div>
				<div id="catlinks" class="catlinks" data-mw="interface"><div id="mw-normal-catlinks" class="mw-normal-catlinks"><a href="/wiki/Special:Categories" title="Special:Categories">Categories</a>: <ul><li><a href="/wiki/Category:SVG_flags_of_Syria" title="Category:SVG flags of Syria">SVG flags of Syria</a></li><li><a href="/wiki/Category:Flags_with_three_horizontal_stripes_of_black,_red_and_white_(centered)_color_combination" title="Category:Flags with three horizontal stripes of black, red and white (centered) color combination">Flags with three horizontal stripes of black, red and white (centered) color combination</a></li><li><a href="/wiki/Category:Flags_with_two_green_five-pointed_stars" title="Category:Flags with two green five-pointed stars">Flags with two green five-pointed stars</a></li><li><a href="/wiki/Category:SVG_flags_with_an_aspect_ratio_of_3:2" title="Category:SVG flags with an aspect ratio of 3:2">SVG flags with an aspect ratio of 3:2</a></li><li><a href="/wiki/Category:SVG_sovereign_state_flags" title="Category:SVG sovereign state flags">SVG sovereign state flags</a></li></ul></div><div id="mw-hidden-catlinks" class="mw-hidden-catlinks mw-hidden-cats-user-shown">Hidden categories: <ul><li><a href="/wiki/Category:Derivative_versions" title="Category:Derivative versions">Derivative versions</a></li><li><a href="/wiki/Category:Valid_SVG_created_with_Other_tools:Flags" title="Category:Valid SVG created with Other tools:Flags">Valid SVG created with Other tools:Flags</a></li><li><a href="/wiki/Category:Self-published_work" title="Category:Self-published work">Self-published work</a></li><li><a href="/wiki/Category:PD-self" title="Category:PD-self">PD-self</a></li></ul></div></div>				<div class="visualClear"></div>
							</div>
		</div>
		<div id="mw-navigation">
			<h2>Navigation menu</h2>

			<div id="mw-head">
									<div id="p-personal" role="navigation" class="" aria-labelledby="p-personal-label">
						<h3 id="p-personal-label">Personal tools</h3>
						<ul>
							<li id="pt-uls" class="active"><a href="#" class="uls-trigger autonym">English</a></li><li id="pt-anonuserpage">Not logged in</li><li id="pt-anontalk"><a href="/wiki/Special:MyTalk" title="Discussion about edits from this IP address [n]" accesskey="n">Talk</a></li><li id="pt-anoncontribs"><a href="/wiki/Special:MyContributions" title="A list of edits made from this IP address [y]" accesskey="y">Contributions</a></li><li id="pt-createaccount"><a href="/w/index.php?title=Special:CreateAccount&amp;returnto=File%3AFlag+of+Syria.svg" title="You are encouraged to create an account and log in; however, it is not mandatory">Create account</a></li><li id="pt-login"><a href="/w/index.php?title=Special:UserLogin&amp;returnto=File%3AFlag+of+Syria.svg" title="You are encouraged to log in; however, it is not mandatory [o]" accesskey="o">Log in</a></li>						</ul>
					</div>
									<div id="left-navigation">
										<div id="p-namespaces" role="navigation" class="vectorTabs" aria-labelledby="p-namespaces-label">
						<h3 id="p-namespaces-label">Namespaces</h3>
						<ul>
														<li id="ca-nstab-image" class="selected"><span><a href="/wiki/File:Flag_of_Syria.svg" title="View the file page [c]" accesskey="c">File</a></span></li>
							<li id="ca-talk"><span><a href="/wiki/File_talk:Flag_of_Syria.svg" rel="discussion" title="Discussion about the content page [t]" accesskey="t">Discussion</a></span></li>
						</ul>
					</div>
										<div id="p-variants" role="navigation" class="vectorMenu emptyPortlet" aria-labelledby="p-variants-label">
												<h3 id="p-variants-label">
							<span>Variants</span>
						</h3>

						<div class="menu">
							<ul>
															</ul>
						</div>
					</div>
									</div>
				<div id="right-navigation">
										<div id="p-views" role="navigation" class="vectorTabs" aria-labelledby="p-views-label">
						<h3 id="p-views-label">Views</h3>
						<ul>
														<li id="ca-view" class="selected"><span><a href="/wiki/File:Flag_of_Syria.svg">View</a></span></li>
							<li id="ca-viewsource"><span><a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;action=edit" title="This page is protected.&#10;You can view its source [e]" accesskey="e">View source</a></span></li>
							<li id="ca-history" class="collapsible"><span><a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;action=history" title="Past revisions of this page [h]" accesskey="h">History</a></span></li>
						</ul>
					</div>
										<div id="p-cactions" role="navigation" class="vectorMenu emptyPortlet" aria-labelledby="p-cactions-label">
						<h3 id="p-cactions-label"><span>More</span></h3>

						<div class="menu">
							<ul>
															</ul>
						</div>
					</div>
										<div id="p-search" role="search">
						<h3>
							<label for="searchInput">Search</label>
						</h3>

						<form action="/w/index.php" id="searchform">
							<div id="simpleSearch">
							<input type="search" name="search" placeholder="Search Wikimedia Commons" title="Search Wikimedia Commons [f]" accesskey="f" id="searchInput"/><input type="hidden" value="Special:Search" name="title"/><input type="submit" name="fulltext" value="Search" title="Search the pages for this text" id="mw-searchButton" class="searchButton mw-fallbackSearchButton"/><input type="submit" name="go" value="Go" title="Go to a page with this exact name if it exists" id="searchButton" class="searchButton"/>							</div>
						</form>
					</div>
									</div>
			</div>
			<div id="mw-panel">
				<div id="p-logo" role="banner"><a class="mw-wiki-logo" href="/wiki/Main_Page"  title="Visit the main page"></a></div>
						<div class="portal" role="navigation" id='p-navigation' aria-labelledby='p-navigation-label'>
			<h3 id='p-navigation-label'>Navigate</h3>

			<div class="body">
									<ul>
						<li id="n-mainpage-description"><a href="/wiki/Main_Page" title="Visit the main page [z]" accesskey="z">Main page</a></li><li id="n-welcome"><a href="/wiki/Commons:Welcome">Welcome</a></li><li id="n-portal"><a href="/wiki/Commons:Community_portal" title="About the project, what you can do, where to find things">Community portal</a></li><li id="n-village-pump"><a href="/wiki/Commons:Village_pump">Village pump</a></li><li id="n-help"><a href="/wiki/Special:MyLanguage/Help:Contents" title="The place to find out">Help center</a></li>					</ul>
							</div>
		</div>
			<div class="portal" role="navigation" id='p-participate' aria-labelledby='p-participate-label'>
			<h3 id='p-participate-label'>Participate</h3>

			<div class="body">
									<ul>
						<li id="n-uploadbtn"><a href="/wiki/Commons:Upload">Upload file</a></li><li id="n-recentchanges"><a href="/wiki/Special:RecentChanges" title="A list of recent changes in the wiki [r]" accesskey="r">Recent changes</a></li><li id="n-latestfiles"><a href="/wiki/Special:NewFiles">Latest files</a></li><li id="n-randomimage"><a href="/wiki/Special:Random/File" title="Load a random file [x]" accesskey="x">Random file</a></li><li id="n-contact"><a href="/wiki/Commons:Contact_us">Contact us</a></li>					</ul>
							</div>
		</div>
			<div class="portal" role="navigation" id='p-electronPdfService-sidebar-portlet-heading' aria-labelledby='p-electronPdfService-sidebar-portlet-heading-label'>
			<h3 id='p-electronPdfService-sidebar-portlet-heading-label'>Print/export</h3>

			<div class="body">
									<ul>
						<li id="electron-print_pdf"><a href="/w/index.php?title=Special:ElectronPdf&amp;page=File%3AFlag+of+Syria.svg&amp;action=redirect-to-electron">Download as PDF</a></li>					</ul>
							</div>
		</div>
			<div class="portal" role="navigation" id='p-tb' aria-labelledby='p-tb-label'>
			<h3 id='p-tb-label'>Tools</h3>

			<div class="body">
									<ul>
						<li id="t-whatlinkshere"><a href="/wiki/Special:WhatLinksHere/File:Flag_of_Syria.svg" title="A list of all wiki pages that link here [j]" accesskey="j">What links here</a></li><li id="t-recentchangeslinked"><a href="/wiki/Special:RecentChangesLinked/File:Flag_of_Syria.svg" rel="nofollow" title="Recent changes in pages linked from this page [k]" accesskey="k">Related changes</a></li><li id="t-specialpages"><a href="/wiki/Special:SpecialPages" title="A list of all special pages [q]" accesskey="q">Special pages</a></li><li id="t-permalink"><a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;oldid=210166516" title="Permanent link to this revision of the page">Permanent link</a></li><li id="t-info"><a href="/w/index.php?title=File:Flag_of_Syria.svg&amp;action=info" title="More information about this page">Page information</a></li><li id="t-cite"><a href="/w/index.php?title=Special:CiteThisPage&amp;page=File%3AFlag_of_Syria.svg&amp;id=210166516" title="Information on how to cite this page">Cite this page</a></li>					</ul>
							</div>
		</div>
				</div>
		</div>
		<div id="footer" role="contentinfo">
							<ul id="footer-info">
											<li id="footer-info-lastmod"> This page was last edited on 18 October 2016, at 18:10.</li>
											<li id="footer-info-copyright">Text is available under the <a href="//creativecommons.org/licenses/by-sa/3.0/">Creative Commons Attribution-ShareAlike License</a>; additional terms may apply.  By using this site, you agree to the <a href="//wikimediafoundation.org/wiki/Terms_of_Use">Terms of Use</a> and <a href="//wikimediafoundation.org/wiki/Privacy_policy">Privacy Policy.</a></li>
									</ul>
							<ul id="footer-places">
											<li id="footer-places-privacy"><a href="https://wikimediafoundation.org/wiki/Privacy_policy" class="extiw" title="wmf:Privacy policy">Privacy policy</a></li>
											<li id="footer-places-about"><a href="/wiki/Commons:Welcome" title="Commons:Welcome">About Wikimedia Commons</a></li>
											<li id="footer-places-disclaimer"><a href="/wiki/Commons:General_disclaimer" title="Commons:General disclaimer">Disclaimers</a></li>
											<li id="footer-places-developers"><a href="https://www.mediawiki.org/wiki/Special:MyLanguage/How_to_contribute">Developers</a></li>
											<li id="footer-places-cookiestatement"><a href="https://wikimediafoundation.org/wiki/Cookie_statement">Cookie statement</a></li>
											<li id="footer-places-mobileview"><a href="//commons.m.wikimedia.org/w/index.php?title=File:Flag_of_Syria.svg&amp;mobileaction=toggle_view_mobile" class="noprint stopMobileRedirectToggle">Mobile view</a></li>
									</ul>
										<ul id="footer-icons" class="noprint">
											<li id="footer-copyrightico">
							<a href="https://wikimediafoundation.org/"><img src="/static/images/wikimedia-button.png" srcset="/static/images/wikimedia-button-1.5x.png 1.5x, /static/images/wikimedia-button-2x.png 2x" width="88" height="31" alt="Wikimedia Foundation"/></a>						</li>
											<li id="footer-poweredbyico">
							<a href="//www.mediawiki.org/"><img src="/static/images/poweredby_mediawiki_88x31.png" alt="Powered by MediaWiki" srcset="/static/images/poweredby_mediawiki_132x47.png 1.5x, /static/images/poweredby_mediawiki_176x62.png 2x" width="88" height="31"/></a>						</li>
									</ul>
						<div style="clear:both"></div>
		</div>
		<script>(window.RLQ=window.RLQ||[]).push(function(){mw.config.set({"wgPageParseReport":{"limitreport":{"cputime":"0.164","walltime":"0.232","ppvisitednodes":{"value":3707,"limit":1000000},"ppgeneratednodes":{"value":0,"limit":1500000},"postexpandincludesize":{"value":34211,"limit":2097152},"templateargumentsize":{"value":13195,"limit":2097152},"expansiondepth":{"value":26,"limit":40},"expensivefunctioncount":{"value":7,"limit":500},"entityaccesscount":{"value":0,"limit":400},"timingprofile":["100.00%  210.053      1 -total"," 96.33%  202.351      1 Template:Information"," 47.64%  100.079      1 Template:Igen"," 38.89%   81.688      1 Template:InFi"," 24.50%   51.465      1 Template:Created_with_Unknown_tool"," 11.97%   25.137      2 Template:Autotranslate"," 10.95%   22.995      1 Template:SVGvalid"," 10.71%   22.507      1 Template:DerivativeVersions"," 10.13%   21.272      1 Template:ISOdate","  9.52%   20.004      2 Template:Created_with"]},"scribunto":{"limitreport-timeusage":{"value":"0.030","limit":"10.000"},"limitreport-memusage":{"value":1623270,"limit":52428800}},"cachereport":{"origin":"mw1238","timestamp":"20170909191129","ttl":1900800,"transientcontent":false}}});});</script><script>(window.RLQ=window.RLQ||[]).push(function(){mw.config.set({"wgBackendResponseTime":147,"wgHostname":"mw1216"});});</script>
	</body>
</html>
