Av Mustafa Panshiri | 5 april 2018
I korthet
- En självvald aningslöshet från samhällets sida försvårar integrationsproblem i Sverige, inte minst vad gäller den stora gruppen ensamkommande.
- Mottagningssystemet för ensamkommande är överbelastat, vilket bland annat fått till följd att barn och ungdomar tilldelats olämpliga gode män och vårdnadshavare.
- Om den så kallade gymnasieamnestin inte går igenom riskerar 9 000 unga män att utvisas.
- Samtidigt riskerar gymnasieamnestin att dra ut på lidandet för många i gruppen ensamkommande. Ett tungt ansvar vilar på det svenska samhället, som har lockat hit människor med orealistiska förväntningar.
Jag växte upp i Nacka.
Att komma till Sverige var som att vinna på lotteri efter ett liv i ett talibanstyrt Kabul. Sverige blev vår räddning. Samtidigt fanns det mycket som var konstigt.
Varför sålde svenska staten alkohol till folket? Hur kunde tjejer och killar bli tillsammans utan att de drog skam över familjen? Hur kunde riset vara av så usel kvalitet? Varför åt man pudding av levrat blod på skolan och varför i h-e drack man mjölk till maten?
<div class="kvartal-meta clearfix" style="color: "><div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-ni-valde-att-inte-se%2F&amp;t=Mustafa+Panshiri%3A+Det+ni+valde+att+inte+se"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Mustafa+Panshiri%3A+Det+ni+valde+att+inte+se+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-ni-valde-att-inte-se%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-ni-valde-att-inte-se%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Mustafa Panshiri: Det ni valde att inte se&body=https://kvartal.se/artiklar/det-ni-valde-att-inte-se/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/1470/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/1470/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2018/04/Mustafa-Panshiri-1.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2018/04/Mustafa-Panshiri-1.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/mustafa-panshiri/">Mustafa&nbsp;Panshiri</a> | 5 april 2018<div class="author-desc">Mustafa Panshiri är integrationsföreläsare och före detta polis. Han har skrivit boken &#8221;Sju råd till Mustafa: Så blir du lagom svensk i världens mest extrema land&#8221;.
</div>    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-ni-valde-att-inte-se%2F&amp;t=Mustafa+Panshiri%3A+Det+ni+valde+att+inte+se"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=Mustafa+Panshiri%3A+Det+ni+valde+att+inte+se+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-ni-valde-att-inte-se%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdet-ni-valde-att-inte-se%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Mustafa Panshiri: Det ni valde att inte se&body=https://kvartal.se/artiklar/det-ni-valde-att-inte-se/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/1470/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/1470/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a href           = "#i-korthet"              class          = "in-short-toggle"         data-articleid = "1470">   <i class="far fa-sticky-note"></i>         <span>I korthet</span>                     </a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 31 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/1470"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-1470">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "1470"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text"><ul>
<li>En självvald aningslöshet från samhällets sida försvårar integrationsproblem i Sverige, inte minst vad gäller den stora gruppen ensamkommande.</li>
<li>Mottagningssystemet för ensamkommande är överbelastat, vilket bland annat fått till följd att barn och ungdomar tilldelats olämpliga gode män och vårdnadshavare.</li>
<li>Om den så kallade gymnasieamnestin inte går igenom riskerar 9 000 unga män att utvisas.</li>
<li>Samtidigt riskerar gymnasieamnestin att dra ut på lidandet för många i gruppen ensamkommande. Ett tungt ansvar vilar på det svenska samhället, som har lockat hit människor med orealistiska förväntningar.</li>
</ul>
    </div>  </div></div><div class="article-beginning ">Jag växte upp i Nacka.</p>
<p>Att komma till Sverige var som att vinna på lotteri efter ett liv i ett talibanstyrt Kabul. Sverige blev vår räddning. Samtidigt fanns det mycket som var konstigt.</p>
<p>Varför sålde svenska staten alkohol till folket? Hur kunde tjejer och killar bli tillsammans utan att de drog skam över familjen? Hur kunde riset vara av så usel kvalitet? Varför åt man pudding av levrat blod på skolan och varför i h-e drack man <em>mjölk </em>till maten?</p>
</div>
<div class="rest-of-article ">
<p>Det var sådant jag initialt funderade mycket på.</p>
<p>Jag kunde inte heller begripa hur två män enligt svensk lag kunde gifta sig med varandra i Sverige. Det var ju moraliskt fel.</p>
<p>Men allt detta gjorde mig samtidigt nyfiken. Jag ville veta hur det kunde komma sig att ett land med så &#8221;omoraliska&#8221; värderingar samtidigt hade ett så pass väl fungerande och välmående samhälle. Jämställdhet, jämlikhet och tolerans var saker som jag såg i min vardag.</p>
<p>I skolan i Nacka gick jag i en klass där en del av mina klasskamrater och lärare &#8221;såg&#8221; mig och förstod min kulturella bakgrund. Ibland blev jag ifrågasatt och utmanad. Stundtals kunde det vara jobbigt, men jag insåg också att jag <em>ville</em> få frågor och diskutera kulturskillnader öppet. Jag ville både förstå och bli förstådd. Det var en insikt jag tog med mig när jag så småningom blev polis.</p>
<h2>Mina möten med ensamkommande</h2>
<p>2014 års &#8221;öppna era hjärtan&#8221;-tal av dåvarande statsminister <strong>Fredrik Reinfeldt </strong>gjorde intryck på mig eftersom min familj och jag flytt krig och terror i Afghanistan med hopp om ett bättre liv i Sverige.</p>
<p>Av över 160 000 människor som kom till Sverige under 2015 var 35 000 så kallade ensamkommande barn och ungdomar. En majoritet av dem kom från Afghanistan. Jag mötte dessa barn och ungdomar nästan dagligen på polisstationen i Linköping i samband med att de ville söka asyl. Jag ville &#8211; helt frivilligt &#8211; vara med och underlätta deras första möte med en svensk myndighet, inte minst för att jag kunde prata dari och persiska.</p>
<p>Jag minns speciellt ett möte med ett barn, som jag skrev om på Linköpingspolisens Facebooksida:</p>
<p style="margin-left: 40px;"><em>Den femton år gamla pojken som stod utanför vår nattreception hade samma nationalitet som jag. När vi satte oss ner för att påbörja förhöret kom jag att tänka på mina upplevelser när jag kom till Sverige tillsammans med mina föräldrar och syskon. Jag var något år yngre än pojken som satt framför mig nu. </em></p>
<p style="margin-left: 40px;"><em>Jag ville berätta för honom att han har kommit till ett fantastiskt land. Jag ville berätta för honom att han har all världens möjligheter till en bättre framtid och att han inte längre behöver vara orolig. </em></p>
<p style="margin-left: 40px;"><em>Jag hann inte säga något av allt detta innan pojken bröt ihop framför mig. Han kunde inte sluta gråta. </em></p>
<p style="margin-left: 40px;"><em>Han berättade om sin resa från Afghanistan via Iran och sedan Turkiet. Vid bergen i Turkiet var de hundratals flyktingar och han kom bort från sin mamma och storebror. Pojken hade tillsammans med en annan familj tagit sig vidare till Tyskland och sedan Danmark och Sverige. </em></p>
<p style="margin-left: 40px;"><em>Han frågade mig med gråten i halsen om han någonsin kommer att se sin mamma igen. Då slog det mig att det inte var förhoppningar om utbildning och bättre framtid som pojken tänkte på nu. Han ville bara ha sin mamma.</em></p>
<p>Redan 2014 besökte jag ensamkommande på HVB-hemmen i Linköping tillsammans med min poliskollega <strong>Håkan Stenbeck</strong>. Håkan och jag ville skapa en relation till ungdomarna och samtidigt informera om vad det innebär att leva i ett demokratiskt och sekulärt samhälle som Sverige &#8211; vilka lagar och regler som gäller här.</p>
<figure>
<blockquote><p>&#8221;De ensamkommande ungdomarna är i en fas i livet där de är mottagliga för, och nyfikna på, den information och de intryck de får.&#8221;</p></blockquote>
</figure>
<p>Besöken på HVB-hemmen ingick inte i mina arbetsuppgifter. Jag fick lägga in extra pass i schemat för att det skulle vara möjligt. Under flyktingvågen 2015 insåg jag att det inte räckte med att besöka boenden i Linköping &#8211; jag ville träffa ensamkommande över hela Sverige. Det slutade med att jag gick på tjänstledighet från polisen. Ett halvt år senare hade jag hunnit besöka över femtio kommuner och jag tänkte: &#8221;Varför inte besöka <em>alla </em>290 kommuner och träffa Sveriges <em>alla </em>ensamkommande?&#8221;</p>
<p>Målet med att träffa dessa ungdomar har varit att hitta gemensamma nämnare mellan dem och svenska samhället. Jag berättar om våra grundlagar och om grundläggande kulturella värderingar som jämställdhet, jämlikhet och individens rätt att bestämma över sitt eget liv.</p>
<p>De ensamkommande ungdomarna är i en fas i livet där de är mottagliga för, och nyfikna på, den information och de intryck de får. Värderingar de fått med sig i barndomen, i en annan del av världen, sitter inte hundra procent än &#8211; varför man ännu har marginal att utmana och ifrågasätta dem. Det är därför jag håller fast vid min vision att besöka så många ensamkommande jag kan.</p>
<h2>Aningslösheten är självvald</h2>
<p>Måndagen den 21 januari 2002 mördades <strong>Fadime Sahindal </strong>av sin pappa. Hon blev mördad för att hon brutit sig loss från familjen och blivit tillsammans med en svensk kille. Vid den tidpunkten gick jag i åttonde klass på högstadiet i Stavsborgsskolan i Älta. I min skola pratade man om nyheter på samhällslektionerna, men ingen tog upp mordet på Fadime. Några klasskompisar till mig förklarade varför: Begreppet &#8221;hederskultur&#8221; var något man inte hade hört talas om, och varför skulle en pappa mörda sin dotter för att hon träffat en kille? Vad fanns det för &#8221;heder&#8221; i det?</p>
<p>Det bristande intresset för hedersförtryck gjorde mig orolig redan som sextonåring; vad för hjälp fanns det att få om någon <em>jag </em>kände drabbades av hedersförtryck? Om det drabbade mig själv? Min syster?</p>
<p>Vem i min omgivning var kunnig nog för att jag skulle kunna prata med henne eller honom om det?</p>
<p>Senare i livet har jag ofta sett samma ovilja att se verkligheten för vad den är.</p>
<p>Min gode vän och poliskollega <strong>Per </strong>har en stor sten sparad i ett skåp. Han fick den kastad mot sig under ett av sina första pass i Husby hösten 2012. Det var ett rutinuppdrag i centrum. Per och hans kollega fick kliva ur bilen och när de kom tillbaka hade det samlats en klunga ungdomar på platsen.</p>
<p>Stämningen blev hotfull.</p>
<p>När patrullen var på väg ner från parkeringsdäcket flög den första stora stenen rakt in i sidofönstret som krossades. Per kunde också konstatera att däcken på polisbilen var sönderskurna. Ibland kommer ljudet av krossat glas tillbaka när Per sluter ögonen.</p>
<p>&#8221;Fast det värsta är ändå insikten att någon så lättvindigt skulle kunna kasta en så stor sten mot andra människor.&#8221; säger han till mig.</p>
<figure>
<blockquote><p>&#8221;Man går hem på kvällen efter att ha varit utsatt för stenkastning som kunde ha kostat en livet, men dagen efter läser man inget om det i media.&#8221;</p></blockquote>
</figure>
<p>Runt 2011 när jag hade påbörjat mina studier på Polishögskolan berättade Per för mig om sin arbetsmiljö på Järvafältet i Stockholm &#8211; hur han och hans kollegor lurades i regelrätta bakhåll och blev utsatta för stenkastning, så kallad <em>police fishing</em>, alltså när någon ringer in falsklarm till 112 enbart i syfte att kunna attackera poliserna.</p>
<p>Sedan krossar man vindrutor och skär sönder däck medan poliserna lämnar bilen utan tillsyn för att ta upp en anmälan eller kontrollera en uppbruten dörr. Det här har fått resultatet att <em>två </em>polisbilar numera måste åka ut på det som förr var rutinjobb i utsatta områden. En extra polisbil åker alltid med för att vakta den obevakade polisbilen.</p>
<p>Jag minns att jag tänkte att Per måste överdriva om de händelser han beskrev för mig. Det han berättade om uppmärksammades ju sällan i kvällstidningar eller på tv.</p>
<p>&#8221;Det är det som är det värsta när jag ser den verkligheten&#8221;, brukar Per säga, &#8221;att samhället i stort inte uppmärksammar det mer. Man går hem på kvällen efter att ha varit utsatt för stenkastning som kunde ha kostat en livet, men dagen efter läser man inget om det i media. Det rapporteras i stället om annan, många gånger  lindrigare, brottslighet ute i landet.</p>
<p>Det är inte händelserna i sig som är det värsta, det är känslan av att se något som resten av samhället inte verkar se. Om det väl rapporteras om det så framställs det som enbart en polisfråga vilket är både oansvarigt och fel. Det är en mycket större fråga än så! Det här gäller <em>hela </em>samhället.&#8221;</p>
<h2>Möten med verkligheten</h2>
<p>I rollen som integrationsföreläsare får jag vara med om många intressanta och situationer. Här är några av dem. (Namnen är fingerade.)</p>
<p>&nbsp;</p>
<h3 class="text-align-center">Morteza vill åka hem</h3>
<p>En kvinna hörde av sig till mig via mejl och bönade och bad om att jag skulle träffa henne och ett ensamkommande barn som bodde inneboende hos henne och hennes man. Barnet, vi kan kalla honom för <strong>Morteza</strong>, hade en vän &#8211; <strong>Ahmed</strong>&#8211; som råkat i problem i Afghanistan och nu behövde Ahmed hjälp. Morteza ville alltså lämna Sverige, mitt under asylprocessen, och åka tillbaka till Afghanistan för att hjälpa sin vän.</p>
<p>En knivig situation.</p>
<p>Så jag bestämde mig för att besöka kvinnan och det ensamkommande barnet som bodde hos dem. Det här var ett pensionärspar som sedan ett år tillbaka låtit Morteza bo hos dem. Morteza hade fått sin ålder uppskriven av Migrationsverket och fått sitt tredje avslag. I princip satt han hemma och väntade på utvisning. Men det äldre paret ville att pojken skulle stanna kvar i Sverige och leva gömd, för att fyra år senare kunna söka asyl på nytt.</p>
<figure>
<blockquote><p>&#8221;Morteza bredvid mig såg till att börja med ut att vara minst trettiofem år gammal. Han hade rynkor i ansiktet och höll på att tappa håret.&#8221;</p></blockquote>
</figure>
<p>Problemet var nu alltså att Mortezas vän Ahmed i Afghanistan ville att Morteza skulle resa ner och hjälpa honom med en svårighet som han inte kunde ta sig ur på egen hand.</p>
<p>Pensionärsparet å sin sida ville inte att Morteza skulle återvända hem. De ville att <em>jag </em>skulle övertala honom att stanna kvar i Sverige. Men det var något som inte stod rätt till här.</p>
<p>Morteza bredvid mig såg till att börja med ut att vara minst trettiofem år gammal. Han hade rynkor i ansiktet och höll på att tappa håret. Jag hade för övrigt träffat honom två år tidigare när han kom till polisstationen i Linköping och sökte asyl som ensamkommande barn. Under det där förhöret med Morteza reagerade jag direkt när han sa att han var sexton år gammal. Mina kolleger på stationen reagerade också, men det var inte vår uppgift att ifrågasatta hans ålder utan vi höll ett kort förhör med &#8221;barnet&#8221; för att sedan kontakta socialtjänsten och Migrationsverket och överlämna ärendet till dem.</p>
<p>Tillbaka till det gamla paret och Morteza. De kallade honom för sitt &#8221;kära barn&#8221; när de tilltalade honom under samtalet.</p>
<p>&#8221;Du kan inte åka till Afghanistan! Du ska ju leva som ett barn så som du har gjort hemma hos oss!&#8221; sa den äldre damen till den trettiofemårige mannen.</p>
<p>Jag ställde kontrollfrågor till Morteza om hans vän Ahmed i Afghanistan och undrade vad för slags trubbel han hamnat i. Av de svar jag fick förstod jag ganska snabbt att det inte fanns någon Ahmed i Afghanistan som behövde hjälp. Morteza hade hittat på historien för att han inte hade hjärta att berätta för sitt värdpar att han ville tillbaka hem. Han hade fått tre avslag från de svenska myndigheterna, och han ville inte chansa på att leva fyra år som illegal flykting för att sedan söka asyl på nytt igen utan några som helst garantier att lyckas.</p>
<p>Morteza har med stor sannolikhet fru och barn som väntade på honom hemma i Afghanistan och de ville i så fall att han skulle återvända hem. Men hur skulle han förklara det för paret som har öppnat sitt hem för honom? Skulle han erkänna att han hittat på allting? Att han ljugit om sin ålder och hela sin livshistoria?</p>
<p>Under samtalet på dari med Morteza hemma hos paret förstod han att <em>jag </em>förstod. Han slog ner blicken och undvek att svara på frågor och jag slutade till slut att ställa dem, av respekt för honom och den pinsamma situation han befann sig i.</p>
<p>Han skämdes och han visste inte hur han skulle ta sig ur det här.</p>
<figure>
<blockquote><p>&#8221;Samtidigt blev jag arg på paret för att de, framför en för detta polis, satt där och talade om att hjälpa en papperslös med att leva gömd undan myndigheterna.&#8221;</p></blockquote>
</figure>
<p>Jag förklarade för honom, på dari, att det är <em>han </em>som bestämmer över sin situation och om han vill åka tillbaka till Afghanistan ska han göra det. Sedan vände jag mig till paret igen och frågade dem om de pressat Morteza till att stanna kvar i Sverige?</p>
<p>&#8221;Nej! Absolut inte&#8221;, sa mannen och kvinnan med en mun.</p>
<p>De vände sig till Morteza och förklarade för honom att det är han som helt och hållet bestämmer om han vill resa tillbaka till sitt hemland. Men <em>om </em>han väljer att stanna kvar och leva gömd i Sverige så hjälper de honom givetvis med det.</p>
<p>Jag såg att Morteza kände sig lättad när han hörde sina värdar lägga fram det så.</p>
<p>Samtidigt blev jag arg på paret för att de, framför en för detta polis, satt där och talade om att hjälpa en papperslös med att leva gömd undan myndigheterna.</p>
<p>Ett par veckor senare fick jag mejl från kvinnan som hade hand om Morteza. Hon var överlycklig eftersom Morteza fått fyra års arbets- och uppehållstillstånd.</p>
<h3></h3>
<h3 class="text-align-center">Fosterflickan på rummet</h3>
<p>Senhösten 2015 när jag fortfarande bar polisuniform fick jag ett samtal från min lillasyster i Stockholm. En afghansk familj som var nära vänner till vår familj hade blivit fosterföräldrar till en ensamkommande flicka från Afghanistan.</p>
<p>&#8221;Fantastiskt!&#8221;, tänkte jag. &#8221;Jag är ute och bidrar med det lilla jag kan och den här familjen bidrar på sitt sätt.&#8221;</p>
<p>Min lillasyster sa att nästa gång jag skulle ner till Stockholm ville de nya fosterföräldrarna gärna bjuda oss på middag. Det blir av några veckor senare.</p>
<p>Det slår mig vid middagen hos våra vänner att fosterflickan inte är närvarande.</p>
<p>&#8221;Hon brukar äta på sitt rum&#8221;, säger mamman i familjen till mig när jag frågar.</p>
<p>&#8221;Aha.&#8221; Jag nickar att jag förstår.</p>
<p>Fast något känns fel och jag har en malande olustkänsla i maggropen.</p>
<p>Efter middagen sitter vi i vardagsrummet och dricker te. Klassisk afghansk tradition. Flickan finns inte med oss då heller. Under tedrickandet börjar mamman i familjen prata om flickan på ett olämpligt sätt som får mig att reagera starkt. Hon pratar dessutom högt så att flickan ska höra det inne i sitt rum.</p>
<p>Jag reser mig upp och går och knackar på hennes dörr för att byta några ord med henne. Flickan öppnar dörren med gråten i halsen och frågar vem jag är. Jag berättar att jag är en vän till familjen, att jag jobbar som polis och att jag träffar ensamkommande som henne i mitt yrke.</p>
<p>Flickan stänger dörren bakom oss och bryter ihop.</p>
<p>Hon berättar att hon inte vill bo med familjen hon blivit placerad hos och att de behandlar henne som skit.</p>
<p>Jag sitter där och lyssnar på hennes tragiska berättelse.</p>
<p>Hon har svårt att få fram orden. Hon är rädd för familjen. Jag får misstankar om sexuella övergrepp och till slut frågar jag henne om detta, men då gråter hon bara ännu mer.</p>
<p>&#8221;Mamman i den här familjen är svartsjuk på mig eftersom pappan ger mig uppmärksamhet&#8221;, säger flickan utan att möta min blick. &#8221;Hon pratar knappt med mig och när hon väl gör det skäller hon på mig.&#8221;</p>
<p>Ju mer jag hör av berättelsen desto mer inser jag att den unga flickan inte ska vara kvar i det här huset. Jag säger till henne att hon ska packa ihop sina saker så ska jag se till att hon kommer därifrån. Sedan går jag ut i vardagsrummet där alla andra sitter och dricker te, mina föräldrar tillsammans med mannen och kvinnan som bor i lägenheten.</p>
<p>Jag sätter mig bredvid mannen och säger att jag har pratat med flickan och att hon mår väldigt dåligt. Jag förklarar vidare att jag det bästa just nu vore om hon blev omplacerad omedelbart.</p>
<p>&#8221;Antingen ringer <em>du </em>till socialtjänsten och berättar läget eller så ringer jag&#8221;, lägger jag till.</p>
<p>Mannen sitter tyst och bara blänger på mig.</p>
<p>Blicken frågar mig vem jag är och vad jag håller på med &#8211; i <em>hans </em>hem. Jag ser att han inte<em> </em>kommer att ringa socialtjänsten, så jag reser mig upp och lämnar lägenheten för att själv göra det.</p>
<figure>
<blockquote><p>&#8221;De undrar vad fan jag håller på med, hur jag som gäst kan lägga mig i den här familjens privata angelägenheter. Samtidigt hör de flickan gråta högt inne på sitt rum, och de förstår att något är väldigt fel.&#8221;</p></blockquote>
</figure>
<p>Det är fredag eftermiddag och jag står på gatan utanför och ringer och får snällt vänta i telefonkö. Till slut får jag kontakt med en kvinna som har kvällsjour. Jag berättar för henne allt det flickan har berättat för mig. Kvinnan som har jour säger att de har mycket att göra men att de kommer att lägga allt åt sidan och komma och hämta henne.</p>
<p>&#8221;Hon ska inte vara kvar där&#8221;, säger hon bestämt.</p>
<p>Jag går upp till lägenheten igen och in i vardagsrummet. Där råder det begravningsstämning.</p>
<p>Mina föräldrar är splittrade. De undrar vad fan jag håller på med, hur jag som gäst kan lägga mig i den här familjens privata angelägenheter. Samtidigt hör de flickan gråta högt inne på sitt rum, och de förstår att något är väldigt fel.</p>
<p>Pappan i familjen sitter i soffan och stirrar på mig med svarta ögon.</p>
<p>Jag går in till flickan och ser att hon har börjat packa, men hon är fortfarande tveksam.</p>
<p>&#8221;Ska vi verkligen åka härifrån?&#8221;, frågar hon mig.</p>
<p>&#8221;Ja&#8221;, säger jag och ler vänligt.</p>
<p>Det tar ungefär fyrtio minuter innan soc anländer. Det är samma kvinna som jag har pratat med i telefon tidigare och hon kommer ensam.</p>
<p>Ryggmärgsreflexen hos mig slår till; som polis åker man sällan ut ensam på en utryckning. Vi jobbar i patrull och har alltid varandras rygg.</p>
<p>&#8221;Vi hade så mycket att göra ikväll så jag tog beslutet att åka själv&#8221;, ursäktar sig socialtjänstkvinnan.</p>
<p>Hon går in till den gråtande fosterflickan och ser att hon har packat färdigt, och sedan säger hon att hon ska prata med familjen också och förklara läget. Hon går in till vardagsrummet och förklarar för familjen att flickan kommer att omhändertas med omedelbar verkan men att familjen är välkomna att överklaga beslutet.</p>
<p>I det ögonblicket reser sig mannen i huset och springer mot henne. Han ställer sig bara några centimer från hennes ansikte.</p>
<p>&#8221;Du är i <em>mitt </em>hus!&#8221;, skriker han ilsket. &#8221;Du har ingen rätt att ta henne ifrån mig! Hon tillhör <em>mig </em>och jag <em>äger </em>henne!&#8221; Smockan hänger i luften.</p>
<p>Jag får gå emellan och förklara för mannen att kvinnan framför honom kommer från en myndighet. Hon är tjänsteman och har ett arbete att utföra. Jag säger till honom:</p>
<p>&#8221;Du kan redan nu har gjort dig skyldig till hot mot tjänsteman. Tänk efter innan du gör något mer.&#8221;</p>
<p>Kvinnan från socialtjänsten börjar gråta.</p>
<p>Efteråt berättade hon att hon under sina femton inom myndigheten aldrig varit så rädd som hon var i just den lägenheten, just då. Det visade sig också att socialtjänsten vid två tillfällen tidigare varit på besök hos den här familjen för att se om flickan mådde bra. Men det hade varit hastiga besök där man i princip bara bockat av på en lista att man varit där.</p>
<p>&#8221;I vanliga fall är vi noggranna med placering av barn hos fosterfamiljer&#8221;, förklarade kvinnan. &#8221;Vi gör flera timmars intervjuer med familjen för att se om just de är lämpliga. Men nu under hösten 2015 har vi haft press på oss att placera, placera, placera ? vi har inte hunnit med våra vanliga rutiner.&#8221; Hon lät mycket sorgsen.</p>
<p>Men vi fick i alla fall med oss flickan till socialkontoret.</p>
<p>I samma byggnad fanns även polisen så ett förhör genomfördes där jag fick agera tolk. Förutom anklagelserna om sexuella närmanden (som aldrig gick att bevisa och som kan ha bottnat i ett svartsjukedrama) berättade flickan om en rad hemska saker hon blivit utsatt för av den aktuella familjen. Bland annat hade de skrämt med henne med att om hon inte diskade så skulle de kontakta Migrationsverket och deportera henne tillbaka till Afghanistan.</p>
<p>Flickan blev till slut placerad hos en annan familj.</p>
<h3></h3>
<h3 class="text-align-center">Belysning mot brottslighet</h3>
<p>Under en taxiresa från Härnösand till Sundsvalls flygplats hamnade jag i en intressant diskussion om de oroligheter som under 2017 drabbat kommunen: knivbråk i centrum plus att tre unga män från Afghanistan satt anhållna misstänkta för dråpförsök. Bråken mellan olika grupperingar hade pågått under en längre tid och kulminerat när gängen stämt träff i centrum och försökt göra upp med knivar.</p>
<p><strong>Ingrid Nilsson</strong> (V), ordförande i Rådet för trygghet och hälsa, påtalade under ett stormöte i kommunen vikten av att förbättra belysningen i centrum för att på så sätt skapa trygghet.</p>
<p>&#8221;Nu måste vi jobba med att befolka torget, göra roliga saker. Alla ska känna att det är ett ställe där man vill och vågar vara,&#8221; sa hon till SVT Västernorrland.</p>
<p>&#8221;Vad tror ni om hennes förslag?&#8221; sa jag till mina medpassagerare i taxin. &#8221;Är det belysningen som är problemet?&#8221;</p>
<p>I baksätet satt en kvinna i sextioårsåldern tillsammans med en yngre kille i tjugofemårsåldern.</p>
<p>&#8221;Ja, alltså ? det kanske hjälper med lite belysning &#8230;&#8221; sa taxichauffören tveksamt.</p>
<p>Jag vände mig om för att få ögonkontakt med kvinnan. Hon sneglade upp från tidningen hon läste, men tittade snabbt ner igen.</p>
<p>&#8221;Om <em>jag </em>bott i Härnösand hade jag blivit rätt förbannad om en lokalpolitiker trodde att gängbråken kunde lösas med att befolka torg och fixa bättre belysning i centrum,&#8221; sa jag krasst.</p>
<figure>
<blockquote><p>&#8221;Att bråken i slutänden kommer att drabba de nyanlända var något som alla i taxin var överens om. &#8221;</p></blockquote>
</figure>
<p>Kvinnan i taxin vaknade till och sa med tydlig och bestämd röst att torget i Härnösand varit dött i åratal.</p>
<p>&#8221;Varenda en i kommunen fattar ju att det är inte är belysningen som är problemet!&#8221; Hon tittade på mig med uppspärrade ögon.</p>
<p>&#8221;Det Ingrid Nilsson inte verkar förstå är att det är <em>precis </em>ett sådant där uttalande som gör folk i kommunen <em>ännu mer </em>förbannade!&#8221;</p>
<p>Under taxifärden beklagade sig de andra passagerarna över politikernas otydlighet kring problem som har med integration och invandring att göra. Att bråken i slutänden kommer att drabba de nyanlända var något som alla i taxin var överens om.</p>
<p>När man inte är ärlig om att det finns individer i en viss grupp som missköter sig och orsakar problem, speciellt i en liten kommun som Härnösand &#8211; ja då börjar folk att spekulera. Det startas Facebookgrupper med arga medborgare som inte sällan låter frustationen gå ut över <em>alla </em>nyanlända.</p>
<p>Jag hade under två dagar i Härnösand träffat ensamkommande som gick i skolan, idrottade och försökte sköta sig. Vissa av ungdomarna berättade för mig att de samtidigt drog sig för att gå ut på kvällarna eftersom de inte vill förknippas med dem som missköter sig.</p>
<h3 class="text-align-center"></h3>
<h3 class="text-align-center">Vem drömmer om mångkultur?</h3>
<p>På en konferens för Region Halland ställde jag frågan som jag alltid ställer till publiken under mina föreläsningar:</p>
<p>&#8221;Vill du leva i ett mångkulturellt samhälle? Och om svaret på frågan är ja, vad är det då specifikt med det mångkulturella samhället som du tycker om? Alltså, vad är det med afghansk kultur, somalisk kultur, eritreansk kultur etcetera som du tror kommer att berika vårt svenska samhälle? Och jag vill <em>inte </em>höra något om maträtter och folkdans.&#8221;</p>
<figure>
<blockquote><p>&#8221;Varför måste människor komma till Sverige och bosätta sig här, bara för att vi ska bli ?berikade?? Är inte det ett litet postkolonialt &#8211; och ganska själviskt &#8211; tänk?&#8221;</p></blockquote>
</figure>
<p>De som sitter i publiken under de här föreläsningarna är gode män, socialsekreterare, personal på HVB-boenden och lärare på skolan som direkt eller indirekt kommer i kontakt med ensamkommande och nyanlända. Men på konferensen i Halland var det chefer, mellanchefer och strateger på kommun- och regionnivå. Jag var nyfiken på vad de skulle svara på min fråga.</p>
<p>Oftast när jag ställer den blir det knäpptyst och när någon väl räcker upp handen brukar svaret bli att utlänningar &#8221;berikar svenskar&#8221; med alla sina olikheter.</p>
<p>Jag brukar då leka djävulens advokat och fråga om svenskarna inte kan åka utomlands och uppleva dessa olikheter? Varför måste människor komma till Sverige och bosätta sig här, bara för att vi ska bli &#8221;berikade&#8221;? Är inte det ett litet postkolonialt &#8211; och ganska själviskt &#8211; tänk?</p>
<p>&#8221;Nej, det är <em>bra </em>att människor kommer hit,&#8221; blir svaret, &#8221;Då lär vi oss ju saker av varandra!&#8221;</p>
<p>De som under föreläsningarna brukar säga att de <em>inte </em>vill leva i ett mångkulturellt samhälle är människor av utländsk härkomst.</p>
<p>Varför?</p>
<p>Jo, dessa människor kommer från &#8221;mångkulturella länder&#8221; och i Sverige bor de i &#8221;mångkulturella&#8221; (läs segregerade, socioekonomiskt utsatta) områden. De som med näbbar och klor försvarar det mångkulturella samhället är oftast etniska svenskar.</p>
<p>Dessa människor bor i <em>icke </em>mångkulturella områden, tillsammans med andra etniska svenskar. Men man har en föreställning om mångkultur som något givande och exotiskt. Det är som en kärleksrelation på avstånd, en platonisk relation där man aldrig har träffats och helst inte <em>vill</em> göra det heller. Men man vill gärna behålla den positiva bilden av sin tilltänkta partner.</p>
<p>Man vill att det ska vara fint och romantiskt.</p>
<p>&nbsp;</p>
<h3 class="text-align-center">Mot lagen för de ensamkommande</h3>
<p>Jag var i en större kommun i Skåne och föreläste för personal och enhetschefer för HVB-hem för ensamkommande barn. En samordnare för ett av HVB-hemmen i kommunen räckte upp handen och frågade mig och åhörarna hur vi skulle jobba för att riva upp det avtal mellan Sverige och Afghanistan som möjliggjorde deporteringar av afghaner som fått avslag på sin asylansökan.</p>
<p>Här hade vi alltså en anställd i en kommun och som är underställd svenska staten och som helt öppet frågar hur hon och hennes kollegor på arbetstid ska kunna verka för att riva upp<em> </em>ett avtal som hennes arbetsgivare tecknat.</p>
<p>På samma arbetsplats fanns även en anställd med ursprung i Afghanistan som fem år tidigare fått sitt tredje avslag från Migrationsverket, men ändå valt att leva &#8221;svart&#8221; i Sverige i fyra år. I dag hade han sitt uppehållstillstånd och jobbade med ensamkommande ungdomar.</p>
<p>Samordnaren och ett flertal anställda på boendet presenterade honom stolt för mig (enhetschefen hade ingen aning om detta utan fick reda på det samtidigt som jag).</p>
<p>Jag tänkte:</p>
<p>&#8221;Vet ungdomarna att den anställde har levt gömd i Sverige under fyra år? Pratar de om det? Ger han ungdomarna råd om hur han levde som gömd? Alltså samtidigt som han får lön från sin arbetsgivare vars uppgift är att förberedda ungdomarna för en eventuell utvisning?&#8221; Men jag hade inte mod nog att ställa de frågorna till samordnaren och personalen under föreläsningen.</p>
<p>Ni kanske tycker att det är fegt?</p>
<p>Eller illojalt mot mina afghanska &#8221;landsmän&#8221;?</p>
<p>Men kan ni förstå mig?</p>
<p>Kan ni förstå hur man kläms, obevekligt, mellan sitt förflutna som flykting och de uppgifter man har som företrädare för svenska myndigheter?</p>
<p>&nbsp;</p>
<h3 class="text-align-center">Vem vågar ge hela bilden?</h3>
<p>I minidokumentären &#8221;Pojkarna på resecentrum&#8221; (Sveriges Radio <a href="http://sverigesradio.se/sida/avsnitt/904028?programid=3381" target="_blank" rel="noopener">12/6</a> och <a href="http://sverigesradio.se/sida/avsnitt/904074?programid=3381" target="_blank" rel="noopener">13/6</a> 2017) får lyssnarna följa <strong>Mustafa </strong>som har fått avslag på sin asylansökan och är inne i ett tungt heroinmissbruk.</p>
<p>Journalisten frågar Mustafa om han ångrar att han kom till Sverige.</p>
<p>Han svarar:</p>
<p>&#8221;Jag ångrar mig. Jag har slösat bort två år av mitt liv här.&#8221;</p>
<p>Men den sista meningen i citatet översätts inte till svenska:</p>
<p>&#8221;Om de gör mitt liv illa kommer jag att göra ert liv illa.&#8221;</p>
<figure>
<blockquote><p>&#8221;Om de gör mitt liv illa kommer jag att göra ert liv illa. &#8221;</p></blockquote>
</figure>
<p>Ett ärligt misstag att lyssnarna inte fick veta vad Mustafa sa? Eller ett fall av <em>lying by omission</em> från journalistens sida?</p>
<h2>Vad mina möten lärt mig</h2>
<p>Under min resor runt om i Sverige har jag stött på ett antal gode män, socialsekreterare, personal på HVB-boenden, fosterföräldrar och liknande som absolut inte borde jobba med nyanlända eller med integration. De är inte lämpade för det, varken professionellt eller vad gäller deras personlighet. Jag träffade en direkt främlingsfientlig man som var god man åt flera ungdomar. Exempelvis ville han vid ett tillfälle att de muslimerna på boendet skulle äta griskött eftersom detta var en &#8221;del av integrationsprocessen&#8221;.</p>
<p>Ändå fick sådana som han &#8211; under långa perioder &#8211; stort ansvar för pengar, rättssäkerhet och för andra människors liv.</p>
<p>Varför? För att Sverige inte hade någon plan för hur integrationen skulle fungera under flyktingvågen 2015. Vi ville väl och vi hade hjärtat på rätt ställe. Vi hoppades på det bästa.</p>
<p>De ensamkommande unga männen från Afghanistan som har kommit till Sverige är inte en homogen grupp. Ungdomarna kommer från olika afghanska folkgrupper, från landsbygden eller storstaden, från fattiga eller rika familjer. En del vet lika mycket om vad ett demokratiskt, sekulärt, jämlikt samhälle innebär som vilken svensk som helst. Andra kan fråga mig vad en kondom är och vad man använder den till.</p>
<p>Under föreläsningar brukar jag fråga ungdomarna: &#8221;Vad tycker ni om yttrandefrihet?&#8221; Många räcker upp handen och säger att yttrandefrihet är något fantastiskt.</p>
<p>Jag går vidare i resonemanget och förklarar:</p>
<p>&#8221;Det finns också något som också heter ?religionskritik?. Det innebär att vi i Sverige har rätt kritisera religioner, idéer, åsikter och ideologier.&#8221;</p>
<p>? och det är någonstans här det brukar bli litet hetsigt på mina föreläsningar.</p>
<figure>
<blockquote><p>&#8221;Att man inte har familj i det nya landet innebär också att det inte finns en patriark som har ögonen på en &#8211; sannolikt en viktig förklaring till att en signifikant andel andel av ungdomarna ägnar sig åt brottslighet.&#8221;</p></blockquote>
</figure>
<p>Kunskapsnivån och värderingarna varierar alltså stort. Men alla dessa människor har i alla fall två saker gemensamt: De har kommit till Sverige för att lyckas, och de är alla här utan sina familjer. Detta kan vara faktorer både för framgång och problem i integrationsprocessen.</p>
<p>Pressen att lyckas för att kunna skicka pengar hem till familjen och släkten i Afghanistan kan sporra ungdomarna att ta ansvar. Att familjen inte finns med kan göra att ungdomarna lättare tar till sig sekulära och demokratiska värderingar och får lättare komma in i den svenska kulturen.</p>
<p>Men pressen att skicka hem pengar kan också krocka med verkligheten. Det är svårt att få ihop tillräckliga summor i ett nytt land där man förväntas leva som ett barn och gå i skolan. Det kan i sin tur bidra till psykisk ohälsa bland de ensamkommande.</p>
<p>Att man inte har familj i det nya landet innebär också att det inte finns en patriark som har ögonen på en &#8211; sannolikt en viktig förklaring till att en signifikant andel andel av ungdomarna ägnar sig åt brottslighet.</p>
<figure>
<blockquote><p>&#8221;Samtidigt växer ett skuggsamhälle där unga män går under jorden och ägnar sig åt prostitution, droger och svartjobb.&#8221;</p></blockquote>
</figure>
<p><a href="https://www.svt.se/nyheter/lokalt/vast/svt-granskar-overgrepp-bland-ensamkommande" target="_blank" rel="noopener">SVT uppmärksammade</a> 2017 att femton ensamkommande från Afghanistan under ett års tid dömts för gruppvåldtäkter där offren har varit andra ensamkommande från Afghanistan. Likaså är det ett nytt fenomen i Sverige att <a href="https://polisen.se/siteassets/dokument/ovriga_rapporter/lagesbild-over-sexuella-ofredanden.pdf" target="_blank" rel="noopener">unga män i grupp</a> omringar kvinnor och barn på badhus och festivaler.</p>
<p>Drogmissbruk är ett annat betydande problem. <a href="https://www.svt.se/nyheter/lokalt/stockholm/ensamkommande-flyktingungdomar-heroinlangarnas-nya-kunder" target="_blank" rel="noopener">SVT rapporterade </a>förra året att nio av tio som greps misstänkta för heroininnehav och langning i Tensta, Rinkeby och Husby var ensamkommande. UNT <a href="https://login.ntm.eu/pren/default.aspx?sn=UNT&amp;meter=true&amp;action=completerequest&amp;redirect=http%3a%2f%2fwww.unt.se%2fnyheter%2fuppsala%2fheroinmissbruk-bland-ensamkommande-i-uppsala-4539926.aspx&amp;callback=http%3a%2f%2fwww.unt.se%2finc%2feprencallback.aspx" target="_blank" rel="noopener">rapporterade</a> om ett nittiotal ensamkommande som missbrukade heroin i Uppsala resecentrum.</p>
<p>Samtidigt <a href="http://sverigesradio.se/sida/avsnitt/1036648?programid=1300" target="_blank" rel="noopener">växer ett skuggsamhälle </a>där unga män går under jorden och ägnar sig åt prostitution, droger och svartjobb.</p>
<p>Jag har pratat öppet om dessa problem med de ungdomar jag har träffat runt om i landet. När jag frågar ungdomarna själva varför dessa problem uppstår har jag fått olika svar. Gällande sexuella övergreppen blir svaret inte sällan:</p>
<p>&#8221;Det finns för mycket frihet i Sverige, vilket vissa av oss helt enkelt inte kan hantera.&#8221;</p>
<p>Drogmissbruket förklaras oftast med asylprocessen: de långa väntetiderna, otydligheten, tristessen och ovissheten.</p>
<h2>Från öppna hjärtan till stängd dörr</h2>
<p>För gruppen ensamkommande gällde det under ett antal år i princip bara att ta sig till den humanitära stormakten så fick man ett uppehållstillstånd. Sa man att man var ett barn var det ingen som kontrollerade det. Man fick boende, man fick mat, man fick gå i skolan.</p>
<p>Och rykten spreds om Sverige. Som ungdomar har berättat för mig:</p>
<p>&#8221;Vi hörde att man fick iPhone när man kom över gränsen&#8221;.</p>
<p>Nu möter jag unga män som säger: &#8221;Varför sa de inte redan vid gränsen till mig att afghaner inte var välkomna till Sverige? Varför sa de inte att just nu hjälper vi bara dem från Syrien? Varför välkomnade de mig med öppna armar för att sen utvisa mig?&#8221;</p>
<figure>
<blockquote><p>&#8221;Senare, när demonstrationen flyttades till Medborgarplatsen, stod det motdemonstranter bestående av barnfamiljer med barnvagnar och skanderade: ?Ut med afghanerna! Ut med afghanerna!? &#8221;</p></blockquote>
</figure>
<p>Efter 180-graderssvängningen i svensk migrationspolitik och migrationsdebatt 2017 valde många av dessa människor att kämpa för att få stanna få kvar. När de ensamkommande demonstrerade på Mynttorget utanför Sveriges Riksdag i fjol blev de attackerade av högerextrema Nordiska Motståndsrörelsen med glåpord och bengaler. Senare, när demonstrationen flyttades till Medborgarplatsen, stod det motdemonstranter bestående av barnfamiljer med barnvagnar och skanderade:</p>
<p><em>&#8221;Ut med afghanerna! Ut med afghanerna!&#8221;. </em></p>
<p>Frustrationen riktades mot en grupp människor som följde Sveriges signalpolitik om öppna hjärtan och som &#8211; i enlighet med denna &#8211; begett sig till det lilla landet uppe i norr.</p>
<figure>
<blockquote><p>&#8221;Många ungdomar jag träffar känner sig i dag svikna av Sverige. Det finns ett utbrett förakt mot politiker och samhällets institutioner bland många av dem.&#8221;</p></blockquote>
</figure>
<p>Man får givetvis tycka att detta är fel. Men kritiken borde riktas mot de politiker och delvis journalister som gjorde att dessa människor lurades hit med löften om ett rikare liv.</p>
<p>Jag ställer dig som läser denna text frågan: Ärligt, vad hade du gjort om du bott i Afghanistan?</p>
<p>Jag vet att jag själv hade gjort likadant som dessa ungdomar. Jag är trettioett år i dag, men hade jag kommit till Sverige under 2015 som ensamkommande hade jag förmodligen hävdat att jag var sexton år gammal. Jag hade också velat ha ett bättre liv, en ljusare framtid och en möjlighet att ta min familj till Sverige.</p>
<p>Många ungdomar jag träffar känner sig i dag svikna av Sverige. Det finns ett utbrett förakt mot politiker och samhällets institutioner bland många av dem. Ilskan riktas inte sällan, paradoxalt nog, mot de frivilligorganisationer som försöker hjälpa dem. En medlem i en av dessa organisationer berättade för mig att ungdomar ringer och skäller ut dem för att inte göra tillräckligt mycket.</p>
<h2>Vem har en plan?</h2>
<p>När jag möter ensamkommande frågar jag dem vad de har för plan för det fall att de får avslag. Svaret brukar bli att man tänker gå under jorden och försöka söka asyl igen efter fyra år. Eller så åker man vidare till ett annat europeisk land och söker lyckan där i stället.</p>
<p>Det finns även de som vill återvända hem. Men det frivilliga återvändandet föll kraftigt förra året. 2016 valde 843 personer att åka frivilligt. 2017 var motsvarande siffra 443. Förra året lyckades polisen verkställa 69 tvångsutvisningar.</p>
<figure>
<blockquote><p>&#8221;Mitt hjärta säger: Ge dem amnesti! Vi lurade ju hit dessa ungdomar med löften om ett bättre liv utan några som helst kontroll av identitet eller ålder.&#8221;</p></blockquote>
</figure>
<p>Om regeringens förslag till amnesti inte går igenom riskerar 9 000 unga män att ställas inför utvisning. Vem som helst förstår att det är en process som kommer att ta decennier. Gränspolisens mål i dag är att kunna dubbla förra årets tvångsutvisningar &#8211; alltså från 69 till 138 stycken.</p>
<p>Regeringens plan är å andra sidan den så kallade &#8221;gymnasieamnestin&#8221;, som nyligen kritiserades grundligt av Lagrådet. Förslaget innebär i korthet att de ensamkommande som kom till Sverige och sökte asyl före 24 november 2015 och har väntat mer än femton månader på asylansökan, kan få ett tillfälligt uppehållstillstånd om de har för avsikt att studera på gymnasiet. Efter avslutade studier har man sex månader på sig att skaffa ett jobb. Misslyckas man med detta får man lämna landet.</p>
<p>Mitt hjärta säger: Ge dem amnesti! Vi lurade ju hit dessa ungdomar med löften om ett bättre liv utan några som helst kontroll av identitet eller ålder. Många av dem pratar i dag svenska och strävar efter att bli en del av vårt samhälle.</p>
<figure>
<blockquote><p>&#8221;År 2011 påbörjade nära 3 700 personer språkintroduktion i svensk gymnasieskola. Av dem hade 0,4 procent tagit gymnasieexamen efter tre år.&#8221;</p></blockquote>
</figure>
<p>I en perfekt värld hade vi också kunnat ge amnesti åt alla dessa människor och samtidigt klargöra för resten av världen att detta är en engångsföreteelse och att vi från och nu har ordning och reda i migrationspolitiken. Men världen är inte perfekt.</p>
<p>Hur många ungdomar kommer att lyckas med att ta en gymnasieexamen? Och hur stor andel kommer att få ett jobb inom sex månader efter examen?</p>
<p>Tidigare siffror ger knappast skäl till optimism: År 2011 påbörjade nära 3 700 personer språkintroduktion i svensk gymnasieskola. Av dem hade 0,4 procent tagit gymnasieexamen efter tre år.</p>
<p>När jag var yngre och bodde i Afghanistan skulle mina syskon och jag vid ett tillfälle få vaccin av min morbror som var läkare. Jag var rädd för sprutor, så jag bad min morbror att föra in sprutan sakta i min arm och sakta ut. Jag trodde att jag kunde kontrollera skeendet och smärtan på det sättet. Min morbror gick med på min önskan. När han var klar hade allt gjort extra ont på grund av det utdragna händelseförloppet.</p>
<p>På samma sätt riskerar man att dra ut på lidandet för de ungdomar som nu hoppas på gymnasieamnestin. För mig spökar bilden av nålen som sakta är på väg in i min arm, och som snart ska ut igen, lika smärtsamt långsamt.</p>
<h2>Fotnot</h2>
<p>Mustafa Panshiri är inte längre verksam som polis. De åsikter som framförs i artikeln är hans egna, och delas inte nödvändigtvis av Polismyndigheten.</p>
<h2>Om artikeln</h2>
<p>Artikeln bygger delvis på ett bearbetat utdrag från Mustafa Panshiris och Jens Ganmans aktuella bok <span style="font-style: italic;"> Det lilla landet som kunde</span> (Vulkan, 2018).</p>
<div class="author-byline">Mustafa Panshiri är integrationsföreläsare och före detta polis. Han har skrivit boken &#8221;Sju råd till Mustafa: Så blir du lagom svensk i världens mest extrema land&#8221;.
</div>
</div>
