Var är gudarna?


<h2 class="wp-block-heading" style="font-size:25px"><mark class="has-inline-color has-luminous-vivid-orange-color">Spår av hedendom på runstenarna</mark></h2>



<p class="has-medium-font-size wp-block-paragraph"><strong>Även om runorna har sina rötter i hedendomen är de allra flesta runstenar från kristen tid – och nämns det någon gud så är det nästan alltid den kristne guden. Men finns det inte några spår av de hedniska gudarna, som ju var i friskt minne på Island ännu på 1200-talet?</strong></p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Fig.-3.-Glavendrupstenen.-Foto-Roberto-Fortuna-NM-edited.jpg" alt="" class="wp-image-2006" width="362" height="362" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">»Tor vige dessa runor» kan man läsa på den berömda Glavendrupstenen på Fyn. Foto: Roberto Fortuna/ Nationalmuseet Danmark</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">FÖR 1600-TALETS</mark></strong> runforskare som menade att runstenarna redan då hade funnits i flera tusen år, var det självklart att texterna speglade en tid före kristendomens införande. Korsen på runstenarna uppfattades som »Tors märke» och emellanåt fann de också namnen på gudomar från både den nordiska och antika mytologin. Exempelvis hade vår förste riksantikvarie Johannes Bureus inga problem att på en småländsk runsten läsa runorna <strong>harþa : guþ : oþin</strong>, som han tolkade som »Hårde Gudh Odhin». De runor som fanns på stenen visade sig senare inte ens vara i närheten av detta.</p>



<p class="wp-block-paragraph">   En av Bureus efterföljare, Uppsalaprofessorn Olof Rudbeck, som knappast kan beskyllas för att ha saknat vetenskaplig fantasi, hade på en annan runsten funnit runföljden <strong>harþa kuþan tryg</strong>. Detta tolkade han som »den hårde gudens tjänare», där den »hårde guden» skulle syfta på »den svenske Mars» det vill säga Tor. Här hamnade Rudbeck på kollisionskurs med den dåvarande riksantikvarien Johan Peringskiöld, som genom sina erfarenheter som runstenstecknare direkt insåg det måste handla om den vanliga runstensfrasen <em>harða gōðan dræng</em>, i dag ofta översatt med »en mycket god (ung) man». Detta hela utvecklade sig till ett så häftigt meningsutbyte att statsmakterna såg sig tvungna att gripa in. Resultatet blev att Peringskiöld förbjöds att avvika från eller kritisera tolkningar som hans föregångare och samtida redan hade levererat. Sådana runstenar som ännu var opublicerade fick han däremot tolka som han ville. Som synes tummade man här en del på den akademiska friheten.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/01/Fig.-1.-H†rde-Gudh-Odhin-Bureus.-Foto-KB-MINDRE-VIKTIG-1024x287.jpg" alt="" class="wp-image-1887" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">ohannes Bureus anteckningar om Fors­hedastenen i Småland, där han trodde sig ha funnit Oden namn. Foto: KB</mark></strong></figcaption></figure>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">STORMAKSTIDENS DRÖMMER OM</mark></strong> en ärorik forntid ersattes sedermera av det nyktrare 1700-talet, där framför allt Uppsalaprofessorn Olof Celsius gjorde rent hus med de gamla antikvariernas idéer. För Celsius var det självklart att runstenarnas Gud avsåg den kristne guden och att de flesta runstenar tillhörde den kristna tiden. Detta är ett resultat som till största delen håller än i dag, även runstenarna ibland kan bära spår av förkristna föreställningar. Hit hör till och med ett så centralt ord som <em>Guð</em>, vilket ursprungligen var neutrum pluralis eftersom det syftade på flera gudar av olika kön. En återspegling av detta äldre förhållande finns i vissa runstensböner där det står <em>Guð hialpin</em> istället för <em>Guð hialpi</em> »Gud hjälpe» och där ändelsen &#8211;<em>in </em>signalerar pluralis. Till och med i Äldre Västgötalagen finns spår av ordets ursprungliga pluralitet i edsformler som <em>Sva se mær gud holl</em>, vilket rent bokstavligt betyder »så må gudarna vara mig nådiga», något som egentligen inte borde ha varit gångbart på 1200-talet.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph" style="font-size:30px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">Troligast är väl att alla namnen avser en och samma gud.</mark></strong></p>
</blockquote>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Fig.-2.-Rkstenens-smalsida.-Foto-Bengt-A.-Lundberg-RAˇ-edited.jpg" alt="" class="wp-image-2004" width="345" height="613" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Rökstenens ena smalsida med ett runchiffer, där man både har lyckats läsa Tors och Odens namn. Foto: Bengt A. Lundberg/RAÄ Arkivsök</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ATT DE HEDNISKA</mark></strong> gudarna omnämns på runstenarna verkar inte ens ha varit vanligt under förkristen tid. På Rökstenens ena smalsida förekommer ett runchiffer som det dröjde ganska länge innan det genomskådades, men där man i dag är ense om att det ska utläsas som <strong>sakumukmini þur</strong>. Enligt den länge vedertagna tolkningen ska detta betyda: »Jag säger ett folkminne: Tor!» Detta ser ut som en rätt otvetydig åkallan av guden Tor, men i den av Henrik Williams föreslagna nytolkningen av Rökstenen lyder samma rad: »Jag säger Ygg era minnen.» Här har alltså Tor eliminerats till förmån för ett pronomen, men samtidigt har plötsligt Oden under ett av sina många namn tagit plats i denna del av texten. I den nytolkning av Rökstenen av Bo Ralph, som kom strax före jul, står dock Tors namn ännu kvar på denna sida av stenen så än är han inte ute ur sagan.</p>



<p class="wp-block-paragraph">   Helt otvetydiga exempel på Tors närvaro förekommer däremot på några danska runstenar. »Tor vige dessa runor» kan man exempelvis läsa på den berömda Glavendrupstenen på Fyn och ytterligare ett par stenar bär snarlika uttryck. Avsikten måste i dessa fall ha varit att ställa minnesmärket under guden Tors beskydd.</p>



<p class="wp-block-paragraph">   En motsvarighet till denna formel återfinns även på den västgötska Velandastenen, men den har här nedkortats till ett minimum: <strong>þur : uiki</strong> »Tor vige!» Det har visserligen föreslagits att det också kan utläsas som »Tor må vika» och att det alltså istället skulle vara uttryck för en kristen åskådning. Även om ett sådant uttryck täcks av runorna på stenen, så är det mot bakgrund av de danska exemplen svårt att tro att inskriften skulle förmedla något annat budskap än dessa. Också geografin talar sitt tydliga språk. Stenen är den västligaste i Västergötland och den står i ensamt majestät åtskilliga mil från de västgötska runstensområdena. Här kunde nog en envis Torsdyrkare få vara ifred även efter det att den nya läran hade fått fäste.</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2023/04/Fig.-4.-Velandastenen-Foto-Bengt-A.-Lundberg-RAˇ-edited-1.jpg" alt="" class="wp-image-3158" width="324" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Velandastenen i Västergötland som slutar med orden »Tor vige!». Foto: Bengt A. Lundberg/RAÄ Arkivsök</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">ODENS NAMN FÖREKOMMER</mark></strong> i en runtext från första hälften av 700-talet, som finns ristad på ett mänskligt skalltak från Ribe i södra Danmark. Texten börjar <strong>ulfuʀ ᴀuk uþin ᴀuk ʜutiuʀ</strong>, där Oden nämns här tillsammans med »Ulv» och någon som kallas »Håtyr». Troligast är väl att alla namnen avser en och samma gud och Oden är ju även annars känd för sina många namn. I övrigt får vi fåfängt leta efter honom på runstenarna. De fornnordiska personnamnen kan ju ibland vara sammansatta med gudanamn, men just Oden verkar inte ha kunnat användas i detta sammanhang. Visserligen finns den bekanta <em>Odendis </em>eller <em>Odendisa</em> på Hassmyrastenen i Västmanland, men det är tveksamt om detta var hennes ursprungliga namn. Namnet ska förmodligen istället utläsas som <em>Ōðin-Dīsa</em>, där <em>Ōðin</em>&#8211; är ett framförställt binamn, kanske för att hon hade ett särskilt gott öga till denna gud. I mansnamnet <em>Odenkar</em>, som är känd från ett antal danska runstenar, antas inte innehålla gudanamnet utan det adjektiv som ligger till grund för detta. <em>Odenkar </em>betyder alltså: ’den som är benägen till raseri’.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/01/Fig.-5.-Ribe-skalltak.-Foto-Lennart-Larsen-NM-1024x815.jpg" alt="" class="wp-image-1891" width="383" height="305" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Odens namn återfinns på ett mänskligt skalltak från Ribe i södra<br />Danmark. FOTO: LENNART LARSEN/NATIONALMUSEET DANMARK</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">EN AV DE</mark></strong> mer bekanta asagudarna som inte alls tycks förekomma på runstenarna är Frö. Mer kreativa runologer har visserligen försökt finna hans namn i den söndertrasade texten på Sparlösastenen, men inget av förslagen har uppnått tillräcklig grad av sannolikhet. Det enda sammanhang där gudanamnet med säkerhet förekommer är som förled i personnamn som till exempel <em>Frösten, Fröbjörn, Frödis </em>och <em>Frögärd</em>. Som synes förekommer det i både mans- och kvinnonamn och det verkar ha varit särskilt populärt i landskapen runt Mälaren och framför allt i Uppland. Det är dock inte säkert att denna namnled från början avsåg guden Frö, utan att det från början handlade om ett ord med betydelsen ’herre’ (gotiskans <em>frauja</em>) som först senare har börjat associeras med denna gudom.</p>



<p class="wp-block-paragraph">   Ännu sämre ställt är det med gudinnorna, som helt verkar saknas. Freja (eller <em>Fröja </em>som hon borde heta hos oss) är på sätt och vis lite närvarande på den nämnda Hassmyrastenen genom att Oden-Disa där sägs ha varit <em>hīfrøyia </em>det vill säga ’husfru’, där leden <em>frøyia </em>’härskarinna’ är samma ord som ingår i gudinnenamnet.</p>


<div class="wp-block-image">
<figure class="alignright size-large is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/01/MIX-607x1024.jpg" alt="" class="wp-image-3159" width="374" height="631" /></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">RUNSTENSTEXTERNA SÄGER ALLTSÅ</mark></strong> inte så mycket om den gamla gudavärlden, men runstenarna utgörs inte bara av text utan kan ibland också bära olika bildframställningar. Det svåra är givetvis att tusen år senare kunna avgöra exakt vad dessa bilder betyder. På flera runstenar – som t.ex. den berömda Århusstenen – avbildas expressionistiska ansiktsmasker som har satts i samband med Oden. När snarlika ansiktsbilder dyker upp på en grupp runstenar i Södermanland är det ofta tillsammans med kristna kors och ett lugn vilar här över anletsdragen som snarare leder tankarna till en Kristusframställning.</p>



<p class="wp-block-paragraph">   I andra fall är det lätt att avgöra. På Altuna­stenen i Uppland behöver man inte tveka om att mannen som sitter i båten nedtill på stenen med en hammare i handen och en bläckfiskliknande skapelse på kroken är guden Tor i kamp med Midgårdsormen. Detta lockar betraktaren att även tolka de övriga av stenens bilder i samma riktning. Högst upp avbildas en man stående på en stegliknande konstruktion. En tysk forskare, Gerd Wolfgang Weber, föreslog redan på 1970-talet att detta var en framställning av Oden i sitt högsäte Hliðskjálf. Mannen verkar ju på sin ena axel ha en fågel som riktar sin näbb mot hans huvud och Weber tolkade detta som en av Odens korpar samtidigt som den andra korpen antogs sväva upptill på stenen ovanför gudens huvud. Mycket talar för att detta är en riktig tolkning, möjligen undantaget den andra korpen som verkar lite för stor. Kanske är det här bättre att se en representation av Oden själv i den örnhamn som han bland annat använde för fly när han hade lagt beslag på skaldemjödet.</p>



<p class="wp-block-paragraph">   På mitten av stenen mellan de båda bilderna avbildas en ryttare som håller ett hornliknande föremål i ena handen. Den har bland annat tolkats som en valkyria, men det skulle ligga närmare till hands att tänka på Heimdal. Problemet är väl att han inte ser ut att blåsa i det eventuella hornet.</p>


<div class="wp-block-image">
<figure class="alignright size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/01/Fig.-9.-Bkstastenen.-Foto-Bengt-A.-Lundberg-RAˇ..jpg" alt="" class="wp-image-1895" width="302" height="453" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Vikingatida skidskytte på Bökstastenen i Balingsta i Uppland. Kan det vara guden Ull? Foto: Bengt A. Lundberg/RAÄ Arkivsök</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">KANSKE GÅR DET </mark></strong>på runstenarna också att identifiera andra mindre kända gudar. Guden Ull måste till exempel att döma av ortnamn som <em>Ullevi, Ulltuna </em>och <em>Ulleråker </em>en gång ha varit föremål för en omfattande kult i de centrala delarna av Sverige. I Eddan har han däremot, som någon (tyvärr minns jag inte vem och var) en gång mycket träffande har uttryckt det, reducerats till en ren sportgud som ägnade sig åt skidåkning och bågskytte. När det på Bökstastenen i Balingsta i Uppland dyker upp en bågskytt på skidor så förstår man att det har varit frestande att i denna gestalt se just guden Ull. På samma sten avbildas också en jaktscen där en ryttare med ett långt spjut förföljer ett hjortdjur. I sällskap har han ett par fågelfigurer. Ryttaren har föreslagits föreställa Oden med sina korpar, men det är tydligt att det inte rör sig om några sådana utan om rovfåglar, sannolikt jaktfalkar. Då är det kanske troligare att det handlar om en skildring ur det verkliga livet. Detta hindrar inte att figuren på skidor kan föreställa Ull. Under vikingatiden verkar han ju ha varit jaktens gud, vilket ju kunde motivera hans närvaro i detta sammanhang.</p>



<p class="wp-block-paragraph">   En annan mycket dunkel gudagestalt är Höner, som trots att han närvarar vid flera avgörande tillfällen i de mytologiska berättelserna bara skymtar förbi i de bevarade källorna. Mest framträdande är hans insats i Valans spådom (<em>Vǫluspá</em>) där han tillsammans med Oden och Lodur väcker liv i de första människorna – Ask och Embla – och skänker dem <em>óðr </em>– sinne och tanke – eller när han enligt Gylfaginning och Ynglingasagan tillsammans med Mimer skickas som gisslan till vanerna. Höner är dessutom en av de gudar som överlever Ragnarök.</p>



<blockquote class="wp-block-quote is-layout-flow wp-block-quote-is-layout-flow">
<p class="wp-block-paragraph" style="font-size:30px"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I Eddan har guden Ull reducerats till en ren sportgud som ägnade sig åt skidåkning och bågskytte.</mark></strong></p>
</blockquote>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">FÖRFATTAREN VIKTRO RYDBERG</mark></strong> – som ju bland annat ägnade sig åt mytologisk forskning – menade att en av de fågelfigurer som fanns avbildade på den nu förstörda Ockelbostenen i Gästrikland var en framställning av just Höner. Detta kan ju verka lite befängt, men enligt Snorre kunde han kallas »den snabba asen», »det långa benet» och »gyttjekonung», vilket tyder på att man har uppfattat honom som någon sorts fågel och då snarast åt vadarhållet. Namnet <em>Höner</em> hör också etymologiskt ihop med ord som <em>hane </em>och <em>höna</em>.</p>



<p class="wp-block-paragraph">   Fågelfiguren på Ockelbostenen lyfter sitt ena ben och ser ut att ha vridit huvudet på ett märkligt sätt samtidigt som den balanserar ett äggliknande föremål på spetsen av näbben. Rydberg tänkte sig att det i första hand handlade om den livgivande vita storken. Andra har velat identifiera Höner med den <em>svarta </em>storken, som i folkmun gick under beteckningen <em>odensvala</em>, eller med den betydligt vanligare tranan. Ortnamnsforskaren Eric Elgqvist föreslog i en artikel 1957 att det <em>óðr </em>som Höner ger de första människorna och som tycks ha haft bibetydelser av ’stark lust, upprörd sinnesstämning’ skulle ha sitt ursprung i tranans bekanta dans, och han hänvisar till ett mycket illustrativt avsnitt om denna fågel i Bremhs klassiska verk <em>Djurens liv:</em></p>


<div class="wp-block-image is-style-rounded">
<figure class="alignleft size-full is-resized"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/01/Fig.-11.-Mynt-med-lutiR.-Foto-Ola-Myrin-SHMM-1.jpg" alt="" class="wp-image-3162" width="364" height="383" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Silvermyntet med runorna – bort glömd gud eller kultfunktionär? FOTO: OLA MYRIN/SHMM</mark></strong></figcaption></figure>
</div>


<p class="wp-block-paragraph"><em>Liksom i övermod tar den upp små stenar och träbitar från marken, kastar upp dem i luften, söker att åter fånga dem, bockar sig flera gånger i följd, lyfter vingarna, dansar, hoppar, springer hastigt fram och tillbaka och uttrycker genom olika slags rörelser hela glädjen i sitt väsen men är dock alltid tilltalande, alltid vacker.</em></p>



<p class="wp-block-paragraph">   Detta är ju precis det som Ockelbostenens ristare har framställt och det ger en osökt förklaring till det föremål som fågeln bär ytterst på den långa näbben. Det är inte omöjligt att detta även illustrerar en annan aspekt av Höner. I eddadikten <em>Vǫluspá </em>sägs efter det att jorden åter har stigit upp ur havet efter Ragnarök, att <em>Þá kná Hœnir hlutvið kiósa</em>. Ordet <em>hlutviðr </em>betyder ordagrant ’lott-trä’, men raden har tolkats på flera olika sätt. Erik Brate översatte det med »Då kan Höner lyckans lotter kasta», medan Lars Lönnroth i den senaste svenska eddaöversättningen från 2016 har »Höne skall välja verktyg att spå med». Kanske har man under vikingatiden – vilket redan Elgqvist har tänkt sig – uppfattat tranans lek med små stenar och träbitar som en sorts lottkastning.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/01/Fig.-12.-漵tre-Skovg唕d-blyamulett.-Foto-S況en-Greve-NM-e1680784618178-1024x295.jpg" alt="" class="wp-image-1898" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">En blyamulett från Østre Skovgård på Bornholm fullristad med runor till skydd mot olika onda väsen. Foto: Søren Greve/Nationalmuseet Danmark</mark></strong></figcaption></figure>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">I DEN ISLÄNDSKA</mark></strong> Flatöboken finns en liten berättelse som omnämner en av svearna dyrkad gud <em>Lýtir</em>, vilken även tycks figurera i några fornsvenska ortnamn som <em>Lytislunda </em>och <em>Lytisbergh</em>. <em>Lýtir </em>har uppfattats som allt från ett öknamn på guden Frö eller som »lottguden» till en beteckning för en kultfunktionär med betydelsen ’lottuttydare, spåman’. På ett arabiskt silvermynt från början av 900-talet som ingår i Historiska museets nya vikingautställning, finns runorna <strong>lutiʀ </strong>inristade, vilka faktiskt utan problem skulle kunna svara mot detta <em>Lýtir</em>. Vad som exakt åsyftas med denna inskrift är givetvis svårt att avgöra, men det kan nämnas att ett annat mynt i samma monter på samma sätt har försetts med gudanamnet <strong>þur </strong>»Tor». Om det har funnits en av svearna dyrkad gud <em>Lýtir </em>kanske denne också har rymt föreställningar om guden Höner.</p>



<figure class="wp-block-image size-large"><img src="https://elbilen.se/wp-content/uploads/sites/3/2022/01/Fig.-10.-F†gelfigur-p†-Ockelbostenen.-Foto-ATA.-VIKTIG-1024x390.jpg" alt="" class="wp-image-1896" /><figcaption class="wp-element-caption"><strong><mark class="has-inline-color has-black-color">Fågelfiguren på Ockelbostenen. Är det en framställning av den lottkastande guden Höner? Foto: ATA</mark></strong></figcaption></figure>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">CHANSEN ATT STÖTA</mark></strong> på gudanamn är säkerligen större i de runinskrifter som inte direkt var tänkta för offentligheten. En runamulett som har påträffats vid Kvinneby på Öland bär exempelvis en text ristad åt en man vid namn Bove, där det bl.a. sägs att »Tor må skydda honom med den hammare, som kom ur havet(?)». Trots att amuletten säkert härrör från 1000-talets senare del nämns här Tor vid namn. På ett par säkert samtida runamuletter från Köpingsvik på samma ö, som är ristade till förmån för en kvinna vid namn Oluv, uppmanas istället »Krist och sankta Maria» skydda henne mot diverse otäckheter. Här nämns »den vrålande tursen», »den trehövdade tursen» och till och med <em>inn argi iǫtunn</em> »den perverterade jätten», alltså den typ av varelser som Tor normalt brukar ägna sin tid åt.</p>



<p class="wp-block-paragraph">   Ganska nyligen har man på Bornholm i Danmark funnit ett antal blyamuletter som på ett liknande sätt är tänkta att skydda den namngivne bäraren mot olika onda väsen. Här talas om troll, tursar och alver, men flera gånger också om <strong>þæɴ grimilika greþ</strong> »den ondskefulla <strong>greþ</strong>». Vad som egentligen avsågs med <strong>greþ </strong>återstår att lista ut, men det var förmodligen ingen trevlig bekantskap.</p>



<p class="wp-block-paragraph"><strong><mark class="has-inline-color has-luminous-vivid-orange-color">AV DE OVAN </mark></strong>nämnda amuletterna är faktiskt ännu ingen tolkad i sin helhet och nya fynd kommer säkert att berika denna för oss ännu rätt okända värld av gudar och mytologiska väsen. Detta kunde man egentligen redan ha misstänkt av Boves amulett från Kvinneby. Även om den troligen har tillkommit under kristen tid, slutar texten med orden: <em>Guð eʀu undiʀ hanum ok yfiʀ hanum</em> »Gudar är över honom och under honom»!</p>
