{"article":{"slug":"solving-the-fox-game","title":"Solving the fox game","subtitle":null,"summary":"Steinar H. Gunderson strongly solves the Norse Fox Game (halatafl): with perfect play the sheep win, even with 19 sheep (18 moving first), and 9 sheep can force a draw. He explains the bitboard representation and retrograde search behind his ~1000-line solver.","content_type":"blog_post","language":"en","canonical_url":"http://blog.sesse.net/blog/tech/2026-11-13-19-51_solving_the_fox_game.html","author":{"name":"Steinar H. Gunderson","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"Steinar H. Gunderson","url":"http://blog.sesse.net/blog","listing_slug":null,"listing":null},"topics":[{"name":"algorithms","slug":"algorithms","url":"https://listedarticles.com/topics/algorithms"},{"name":"programming","slug":"programming","url":"https://listedarticles.com/topics/programming"},{"name":"mathematics","slug":"mathematics","url":"https://listedarticles.com/topics/mathematics"}],"about_listings":[],"cover_image_url":null,"license":"all-rights-reserved","word_count":2096,"reading_minutes":9,"published_at":"2026-11-13T18:51:00.000Z","added_at":"2026-11-14T11:13:32.259Z","updated_at":"2026-11-14T11:13:32.259Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/solving-the-fox-game","markdown_url":"https://listedarticles.com/articles/solving-the-fox-game.md","example":false,"citation":"Steinar H. Gunderson, Steinar H. Gunderson. \"Solving the fox game.\" 13 Nov 2026. http://blog.sesse.net/blog/tech/2026-11-13-19-51_solving_the_fox_game.html (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"http://blog.sesse.net/blog/tech/2026-11-13-19-51_solving_the_fox_game.html"},"body_markdown":"# Solving the fox game\n\nChristoffer Stjernlöf [posted about the Fox Game](https://entropicthoughts.com/what-the-fox-say),\nan old Norse asymmetric board game (seemingly also called “halatafl”) where\ntwenty sheep try to outsmart two foxes and get to the other side.\nHis AI uncovered some interesting insights, but left the question open as of whether the\nfoxes or the sheep actually win with perfect play (the general sentiment\nin his family was that winning with the foxes was easy). This was too tempting\nfor me to leave on the table, so I set out to make a strong solve.\n\nSince I don't know this game myself, I've stayed with the rules he describes\neven when they differ from e.g. [Wikipedia](https://en.wikipedia.org/wiki/Fox_games)\n(in particular, I do not use forced fox jumps, or multi-jumps); the only\nreal change is that I don't have a 40-move draw rule, any position that is\na forced win for one of the sides would be a win no matter how long it would\ntake. (I consider this just an implementation detail in his AI, although\nmorally, I consider a draw a loss for the sheep.) You might want to read\nhis post to get the full rules, because I'm not going to repeat them here.\n\nThe results first: The sheep win with perfect play, even with only 19 sheep\n(remove one on the flank), or 18 if they are allowed to go first. Even with\nonly 9 sheep (the minimum possible that isn't an instant win for the foxes),\nthe sheep can force a draw right from the start. With one fox, 11 sheep\nsuffice for a forced win. (The draw margin is seemingly so large because\none fox can just camp in the last spot in the pen, and it's hard to force\nit away without getting harassed by the other fox, unless you have lots of sheep.)\n\nThe rest is about the implementation. I'll skip over a lot of wrong turns,\nand unsurprisingly, there were a lot of bugs to iron out, but hopefully,\nit got to a good place in the end. :-) I started out trying to make something\nvery simple, and it worked for the first few cases, but then things got\nmore complicated than I would have liked in the end. Still only at ~1000\nlines of code, though, with no dependencies.\n\n## Board representation\n\nThe board has 33 squares. I tried a few different ways of represent the state\nof the game, and ended up on a simple bitboard representation: There's a\n64-bit bitmap representing where there are sheep, and another bitmap\nrepresenting where there are foxes. Since there's plenty of room in there,\nI use a spare bit to represent side-to-move. This is compact (which mattered\na lot earlier on, but not as much later), easy to iterate over, and has\nlittle redundancy, so it's easy to keep valid. You need fast 64-bit population\ncount and bit-scan instructions, but a) that's common now everywhere,\nand b) I decided fairly early that I wanted to require BMI2 anyway.\n\nThe bit order mostly doesn't matter; I just started at top-left and went\nfrom there. All it really influences is square iteration order. There's\na small tweak in that I store the right half of the board mirrored\n(reverse x order) for symmetry purposes; more on that below.\n\n## Move generation\n\nI just typed in every possible move from every square into an array,\nthen verified by generating some SVGs that I hadn't made any typos (I had).\nIn retrospect, I should have done something more automated; it would have\nbeen less painful.\n\nThe moves for sheep are just “you can go to X, Y or Z”. The moves\nfor foxes are “you can go to X or Y, or you can go to Z if there's\na sheep at W (which will be eaten)”. The move generator mostly just looks up\nthe source square and tests every move. For the sheep, I make an easy\ntest using bitboards; for the foxes, I could probably do something\nsimilar, but the jump moves proved a bit tricky (even with PEXT/PDEP)\nand I didn't end up using it.\n\nThis is the part that really determines the geometry of the board\n(apart from debugging display). Everything else is pretty much geometry-agnostic.\n\n## Result storage\n\nThere's a little over 2^41 possible board states (this includes some\nillegal positions as well as some situations that could never arise\nduring actual gameplay, such as a fox being stuck at C1 with a row\nof sheep ahead of it), and I want to remember all of them. With that\nmany positions, I figured I needed a fairly compact representation.\nI needed to store that a position could be sheep win, fox win or\na draw, and then there was a fourth “invalid” state that was useful\nfor internal reasons, so that maps exactly to two bits per position.\n(A tablebase intended for distribution could be compressed to less using the usual\ntricks of entropy coding, skipping half of the positions, or similar.)\n\nThis means we need to give a number to every possible position, ideally\none with no collisions and no holes. I learned about\n[combinatorial number systems](https://en.wikipedia.org/wiki/Combinatorial_number_system)\nwhich fit the bill exactly; given e.g. “we have 33 squares and 15 pieces”,\nit gives a dense mapping of positions from board to ID (ranking) and the\nopposite (unranking). (I made some fairly fast ranking and unranking\nalgorithms, which may or may not have been novel, but it turned out\nI didn't actually need fast unranking after some other optimizations.)\nThere are some extra complications in that there are two types of\npieces, but you can solve them in a number of ways.\n\nOn a macro level, I store everything with 9 sheep and 1 fox first,\nthen 9 sheep and 2 foxes, 10 sheep and 1 fox, and so on. This gives\nbeautiful locality (a single move can never remove more than one sheep,\nand only extremely rarely more than one fox), allowing me to just\nmmap everything and let the kernel deal with it, even though I only\nhad 256GB of RAM and the total set was larger (329,870,110,455\nbytes after the symmetry optimizations below).\n\nmmap is almost never the right answer, but again, I was trying to\ngo for simplicity. It certainly brought me pain, though, and perhaps\nsome more explicit I/O would have been better.\n\n## Symmetry\n\nThe board is left-right symmetric (with an odd number of columns,\nso that there is a middle column that is neither “left” nor “right”).\nI had hoped to just ignore this, but eventually the gains became\ntoo important to ignore, so I conceded.\n\nThe basic idea is that I ranked the board twice, both as itself\nand mirrored (mirroring is just a couple of masks and shifts, given\nmy representation), and picked the key that was the smaller as canonical.\nThis reduced the number of positions I needed to look at to a bit\nover 50%, as expected, but it does nothing to the storage/RAM\nrequirements; the new rank is not dense and the “illegal”\n(non-canonical) positions are spread out a bit all over the place\n(although of course near the low and high ends of values,\nit works much better).\n\nAs a tweak, I chose to compute all 33+281 canonical fox positions\nand renumbered using those placements as an assumption. This slashes ~95% of\nthe waste, which is good enough; you can still rank a\nnonconical position if the foxes are symmetric about the center\n(or if there's only one fox and it's in the middle!), though.\n\nYou can improve on this by making the macro-splitting finer;\ninstead of having a chunk for e.g. “10 sheep, 2 foxes”, you\ncould have one with “5 sheep in left, 0 foxes in left, 1 sheep\ncenter, 1 fox center, 4 sheep in right, 1 fox in right”\nand demand that there are more sheep in left than right.\nHowever, you still get problems when the number is balanced,\nyou'd need finer splitting etc.. The gains are small enough\nthat I didn't see the point in doing this, and it tends to be\na place where it's easy to introduce bugs.\n\nI imagined calculating the exact number of positions up to symmetry\nwould be an interesting exercise somehow, but I suppose it just\nimmediately falls to [Burnside's lemma](https://en.wikipedia.org/wiki/Burnside%27s_lemma)\nas soon as you know how to count positions at all.\n\n## Searching\n\nNow that we have positions and moves and a way to store results,\nwe want to know how to find the result for the starting position\n(and ideally also all other positions).\n\nMy first attempt just did a depth-first search, caching as it went.\nThis worked for the earlier stages but was generally a disaster; it ran out of stack\neasily (even with 8 GB—eight *gigabytes* of stack), and had problems\nwith figuring out loops. (It didn't loop infinitely, but was prone\nto declaring loops where one side could break out of the loop by winning.\nI had a nasty hack to fix that, but it didn't really feel good.)\n\nWhat I did instead was propagating results one step at a time.\nFor each possible position:\n\n1. If from a given position you know you can immediately win\n   (e.g., the sheep reach the pen, or the fox eats the last\n   relevant sheep), mark it as such.\n2. If you can, in one move, reach a known-won position, mark your\n   position as won (for the side to move). Similarly, if you can only reach known-lost\n   positions, mark your position as lost.\n3. Repeat #2 over and over again until you no longer have changes.\n\nThis was simple but still inefficient; I typically needed 40–80\npasses for each chunk (where a chunk is something like “all\npositions with 15 sheep, 2 foxes”). However, it was super-easy to parallelize;\nI have 64 cores and could just hand out reasonable independent sub-chunks,\nyou don't even need locking or atomic operations on the result set.\n\nThe correct way of doing this is retrograde analysis (replace #2\nwith doing backwards moves) and I assume this would have made the\ncalculation roughly ten times as fast. But I only needed ~36 hours\nfor the actual run (plus numerous pre-runs that failed for various\nreasons!), so I never got to this. After all, I wanted something\nsimple to begin with.\n\n## Distance-to-win\n\nSince I only store win/draw/loss (WDL) for each position (also known as\na “bitbase” in chess tablebases), it's not\neasy to know what the *fastest* way to win is; just that “this move\ndoes not mess it up, the other side still can't force a draw”.\nHowever, in practice, you could just do reasonable-looking moves that don't\nregress the position, and take forward moves whenever you can (i.e., do sheep\npushes if that still wins).\n\nI made a simple alpha-beta searcher that tries to get win distances\nusing the bitbase as a guide, which was a really fun challenge!\nIt can find wins when they're perhaps ~20 ply (10 moves for each side)\naway, depending a bit on how narrow the win is (if there are only\na few ways to win, it will obviously have to search a much smaller\ntree). Ultimately, though, alpha-beta for finding exact mate scores is just\na losing game, since even perfect move ordering will only give you\na sqrt() improvement over pure minimax.\n\nPerhaps making DTZ (distance-to-zeroing, referring to zeroing the\ndraw move counter in e.g. chess) bases would be possible\nwithout breaking the bank on storage space; I would assume that\nusually, you can force some sort of progress pretty fast, at least\nas the sheep.\n\n## Try it out\n\nI made a very rudimentary interface to the database; the UI isn't\nvery nice, and it largely relies on hovering (which doesn't work all that\nwell on mobile) but I didn't want a polished game-player, just to know the\nanswer. :-) You can try it out at\n<https://sheep.sesse.net/>,\nalthough I don't envision keeping it up forever. Perhaps someone can\ngain new insight from it and become an expert player, although strong\nsolves are rarely very insightful in themselves due to the brute-force\nnature. At least we've conclusively settled (again, under this ruleset!)\nthat the sheep win with perfect play.\n\nEarlier, I would publish the source, but these days, the only ones\nwho would be reading it would be the AI beast (fox?), and I'm not really\nso interested in that. :-) I'm definitely open to answering questions\nif anyone should have them; contact information at my home page as usual.\n","body_html":"<h1 id=\"solving-the-fox-game\">Solving the fox game</h1>\n<p>Christoffer Stjernlöf <a href=\"https://entropicthoughts.com/what-the-fox-say\" rel=\"nofollow ugc noopener\">posted about the Fox Game</a>,\nan old Norse asymmetric board game (seemingly also called “halatafl”) where\ntwenty sheep try to outsmart two foxes and get to the other side.\nHis AI uncovered some interesting insights, but left the question open as of whether the\nfoxes or the sheep actually win with perfect play (the general sentiment\nin his family was that winning with the foxes was easy). This was too tempting\nfor me to leave on the table, so I set out to make a strong solve.</p>\n<p>Since I don&#39;t know this game myself, I&#39;ve stayed with the rules he describes\neven when they differ from e.g. <a href=\"https://en.wikipedia.org/wiki/Fox_games\" rel=\"nofollow ugc noopener\">Wikipedia</a>\n(in particular, I do not use forced fox jumps, or multi-jumps); the only\nreal change is that I don&#39;t have a 40-move draw rule, any position that is\na forced win for one of the sides would be a win no matter how long it would\ntake. (I consider this just an implementation detail in his AI, although\nmorally, I consider a draw a loss for the sheep.) You might want to read\nhis post to get the full rules, because I&#39;m not going to repeat them here.</p>\n<p>The results first: The sheep win with perfect play, even with only 19 sheep\n(remove one on the flank), or 18 if they are allowed to go first. Even with\nonly 9 sheep (the minimum possible that isn&#39;t an instant win for the foxes),\nthe sheep can force a draw right from the start. With one fox, 11 sheep\nsuffice for a forced win. (The draw margin is seemingly so large because\none fox can just camp in the last spot in the pen, and it&#39;s hard to force\nit away without getting harassed by the other fox, unless you have lots of sheep.)</p>\n<p>The rest is about the implementation. I&#39;ll skip over a lot of wrong turns,\nand unsurprisingly, there were a lot of bugs to iron out, but hopefully,\nit got to a good place in the end. :-) I started out trying to make something\nvery simple, and it worked for the first few cases, but then things got\nmore complicated than I would have liked in the end. Still only at ~1000\nlines of code, though, with no dependencies.</p>\n<h2 id=\"board-representation\">Board representation</h2>\n<p>The board has 33 squares. I tried a few different ways of represent the state\nof the game, and ended up on a simple bitboard representation: There&#39;s a\n64-bit bitmap representing where there are sheep, and another bitmap\nrepresenting where there are foxes. Since there&#39;s plenty of room in there,\nI use a spare bit to represent side-to-move. This is compact (which mattered\na lot earlier on, but not as much later), easy to iterate over, and has\nlittle redundancy, so it&#39;s easy to keep valid. You need fast 64-bit population\ncount and bit-scan instructions, but a) that&#39;s common now everywhere,\nand b) I decided fairly early that I wanted to require BMI2 anyway.</p>\n<p>The bit order mostly doesn&#39;t matter; I just started at top-left and went\nfrom there. All it really influences is square iteration order. There&#39;s\na small tweak in that I store the right half of the board mirrored\n(reverse x order) for symmetry purposes; more on that below.</p>\n<h2 id=\"move-generation\">Move generation</h2>\n<p>I just typed in every possible move from every square into an array,\nthen verified by generating some SVGs that I hadn&#39;t made any typos (I had).\nIn retrospect, I should have done something more automated; it would have\nbeen less painful.</p>\n<p>The moves for sheep are just “you can go to X, Y or Z”. The moves\nfor foxes are “you can go to X or Y, or you can go to Z if there&#39;s\na sheep at W (which will be eaten)”. The move generator mostly just looks up\nthe source square and tests every move. For the sheep, I make an easy\ntest using bitboards; for the foxes, I could probably do something\nsimilar, but the jump moves proved a bit tricky (even with PEXT/PDEP)\nand I didn&#39;t end up using it.</p>\n<p>This is the part that really determines the geometry of the board\n(apart from debugging display). Everything else is pretty much geometry-agnostic.</p>\n<h2 id=\"result-storage\">Result storage</h2>\n<p>There&#39;s a little over 2^41 possible board states (this includes some\nillegal positions as well as some situations that could never arise\nduring actual gameplay, such as a fox being stuck at C1 with a row\nof sheep ahead of it), and I want to remember all of them. With that\nmany positions, I figured I needed a fairly compact representation.\nI needed to store that a position could be sheep win, fox win or\na draw, and then there was a fourth “invalid” state that was useful\nfor internal reasons, so that maps exactly to two bits per position.\n(A tablebase intended for distribution could be compressed to less using the usual\ntricks of entropy coding, skipping half of the positions, or similar.)</p>\n<p>This means we need to give a number to every possible position, ideally\none with no collisions and no holes. I learned about\n<a href=\"https://en.wikipedia.org/wiki/Combinatorial_number_system\" rel=\"nofollow ugc noopener\">combinatorial number systems</a>\nwhich fit the bill exactly; given e.g. “we have 33 squares and 15 pieces”,\nit gives a dense mapping of positions from board to ID (ranking) and the\nopposite (unranking). (I made some fairly fast ranking and unranking\nalgorithms, which may or may not have been novel, but it turned out\nI didn&#39;t actually need fast unranking after some other optimizations.)\nThere are some extra complications in that there are two types of\npieces, but you can solve them in a number of ways.</p>\n<p>On a macro level, I store everything with 9 sheep and 1 fox first,\nthen 9 sheep and 2 foxes, 10 sheep and 1 fox, and so on. This gives\nbeautiful locality (a single move can never remove more than one sheep,\nand only extremely rarely more than one fox), allowing me to just\nmmap everything and let the kernel deal with it, even though I only\nhad 256GB of RAM and the total set was larger (329,870,110,455\nbytes after the symmetry optimizations below).</p>\n<p>mmap is almost never the right answer, but again, I was trying to\ngo for simplicity. It certainly brought me pain, though, and perhaps\nsome more explicit I/O would have been better.</p>\n<h2 id=\"symmetry\">Symmetry</h2>\n<p>The board is left-right symmetric (with an odd number of columns,\nso that there is a middle column that is neither “left” nor “right”).\nI had hoped to just ignore this, but eventually the gains became\ntoo important to ignore, so I conceded.</p>\n<p>The basic idea is that I ranked the board twice, both as itself\nand mirrored (mirroring is just a couple of masks and shifts, given\nmy representation), and picked the key that was the smaller as canonical.\nThis reduced the number of positions I needed to look at to a bit\nover 50%, as expected, but it does nothing to the storage/RAM\nrequirements; the new rank is not dense and the “illegal”\n(non-canonical) positions are spread out a bit all over the place\n(although of course near the low and high ends of values,\nit works much better).</p>\n<p>As a tweak, I chose to compute all 33+281 canonical fox positions\nand renumbered using those placements as an assumption. This slashes ~95% of\nthe waste, which is good enough; you can still rank a\nnonconical position if the foxes are symmetric about the center\n(or if there&#39;s only one fox and it&#39;s in the middle!), though.</p>\n<p>You can improve on this by making the macro-splitting finer;\ninstead of having a chunk for e.g. “10 sheep, 2 foxes”, you\ncould have one with “5 sheep in left, 0 foxes in left, 1 sheep\ncenter, 1 fox center, 4 sheep in right, 1 fox in right”\nand demand that there are more sheep in left than right.\nHowever, you still get problems when the number is balanced,\nyou&#39;d need finer splitting etc.. The gains are small enough\nthat I didn&#39;t see the point in doing this, and it tends to be\na place where it&#39;s easy to introduce bugs.</p>\n<p>I imagined calculating the exact number of positions up to symmetry\nwould be an interesting exercise somehow, but I suppose it just\nimmediately falls to <a href=\"https://en.wikipedia.org/wiki/Burnside%27s_lemma\" rel=\"nofollow ugc noopener\">Burnside&#39;s lemma</a>\nas soon as you know how to count positions at all.</p>\n<h2 id=\"searching\">Searching</h2>\n<p>Now that we have positions and moves and a way to store results,\nwe want to know how to find the result for the starting position\n(and ideally also all other positions).</p>\n<p>My first attempt just did a depth-first search, caching as it went.\nThis worked for the earlier stages but was generally a disaster; it ran out of stack\neasily (even with 8 GB—eight <em>gigabytes</em> of stack), and had problems\nwith figuring out loops. (It didn&#39;t loop infinitely, but was prone\nto declaring loops where one side could break out of the loop by winning.\nI had a nasty hack to fix that, but it didn&#39;t really feel good.)</p>\n<p>What I did instead was propagating results one step at a time.\nFor each possible position:</p>\n<ol><li><p>If from a given position you know you can immediately win</p><p> (e.g., the sheep reach the pen, or the fox eats the last\n relevant sheep), mark it as such.</p></li><li><p>If you can, in one move, reach a known-won position, mark your</p><p> position as won (for the side to move). Similarly, if you can only reach known-lost\n positions, mark your position as lost.</p></li><li>Repeat #2 over and over again until you no longer have changes.</li></ol>\n<p>This was simple but still inefficient; I typically needed 40–80\npasses for each chunk (where a chunk is something like “all\npositions with 15 sheep, 2 foxes”). However, it was super-easy to parallelize;\nI have 64 cores and could just hand out reasonable independent sub-chunks,\nyou don&#39;t even need locking or atomic operations on the result set.</p>\n<p>The correct way of doing this is retrograde analysis (replace #2\nwith doing backwards moves) and I assume this would have made the\ncalculation roughly ten times as fast. But I only needed ~36 hours\nfor the actual run (plus numerous pre-runs that failed for various\nreasons!), so I never got to this. After all, I wanted something\nsimple to begin with.</p>\n<h2 id=\"distance-to-win\">Distance-to-win</h2>\n<p>Since I only store win/draw/loss (WDL) for each position (also known as\na “bitbase” in chess tablebases), it&#39;s not\neasy to know what the <em>fastest</em> way to win is; just that “this move\ndoes not mess it up, the other side still can&#39;t force a draw”.\nHowever, in practice, you could just do reasonable-looking moves that don&#39;t\nregress the position, and take forward moves whenever you can (i.e., do sheep\npushes if that still wins).</p>\n<p>I made a simple alpha-beta searcher that tries to get win distances\nusing the bitbase as a guide, which was a really fun challenge!\nIt can find wins when they&#39;re perhaps ~20 ply (10 moves for each side)\naway, depending a bit on how narrow the win is (if there are only\na few ways to win, it will obviously have to search a much smaller\ntree). Ultimately, though, alpha-beta for finding exact mate scores is just\na losing game, since even perfect move ordering will only give you\na sqrt() improvement over pure minimax.</p>\n<p>Perhaps making DTZ (distance-to-zeroing, referring to zeroing the\ndraw move counter in e.g. chess) bases would be possible\nwithout breaking the bank on storage space; I would assume that\nusually, you can force some sort of progress pretty fast, at least\nas the sheep.</p>\n<h2 id=\"try-it-out\">Try it out</h2>\n<p>I made a very rudimentary interface to the database; the UI isn&#39;t\nvery nice, and it largely relies on hovering (which doesn&#39;t work all that\nwell on mobile) but I didn&#39;t want a polished game-player, just to know the\nanswer. :-) You can try it out at\n<a href=\"https://sheep.sesse.net/\" rel=\"nofollow ugc noopener\">https://sheep.sesse.net/</a>,\nalthough I don&#39;t envision keeping it up forever. Perhaps someone can\ngain new insight from it and become an expert player, although strong\nsolves are rarely very insightful in themselves due to the brute-force\nnature. At least we&#39;ve conclusively settled (again, under this ruleset!)\nthat the sheep win with perfect play.</p>\n<p>Earlier, I would publish the source, but these days, the only ones\nwho would be reading it would be the AI beast (fox?), and I&#39;m not really\nso interested in that. :-) I&#39;m definitely open to answering questions\nif anyone should have them; contact information at my home page as usual.</p>","headings":[{"level":1,"text":"Solving the fox game","id":"solving-the-fox-game"},{"level":2,"text":"Board representation","id":"board-representation"},{"level":2,"text":"Move generation","id":"move-generation"},{"level":2,"text":"Result storage","id":"result-storage"},{"level":2,"text":"Symmetry","id":"symmetry"},{"level":2,"text":"Searching","id":"searching"},{"level":2,"text":"Distance-to-win","id":"distance-to-win"},{"level":2,"text":"Try it out","id":"try-it-out"}]}}