TopCoder Statistics - Problem Statement

Problem Statement

The test data for this problem contains the backslash character ('\'). Please note that in all examples the backslash characters are "escaped". That is, each backslash is printed as two consecutive backslashes. For example, the string "/-\\" is a string of length 3 that contains a forward slash, a horizontal dash, and a single backslash.

Elly is designing a roller coaster theme park. The roller coasters will be built on a rectangular field. We will use the words "up", "down", "left", and "right" to refer to the four cardinal directions in the field. The field is divided into a grid of square cells. Currently, each cell is either empty or it contains a pylon which will support a rail segment.

Each rail segment will connect exactly two of the four sides of its cell. This means that there are only two basic types of rail segments: straight segments and segments that make a 90-degree turn. A straight segment connects two opposite sides of its cell, and a turning segment connects two adjacent sides.

There are five types of pylons. Each pylon type does only admit two possible rail segments. In particular:

A pylon of type 'S' does only admit a straight rail segment.
A pylon of type 'U' does only admit a segment that makes a 90-degree turn. Additionally, one end of this segment must point up.
Pylons of types 'D', 'L', and 'R' are similar to pylons of type 'U', but this time one end of the segment must point down, left, or right, respectively.

For example, a pylon of type 'U' can either support a segment that connects the upper side and the left side of its cell, or a segment that connects the upper side and the right side of its cell.

Each specific type of a segment will be denoted by a character, as follows:

A horizontal segment will be denoted '-' and a vertical segment will be denoted '|'. (These are the two options for a pylon of type 'S'.)
The character '/' will be used to denote both a segment that connects up and left and a segment that connects down and right.
The character '\' will be used to denote both a segment that connects up and right and a segment that connects down and left.

The investor has several requirements Elly has to satisfy:

Elly must place a railroad segment onto each of the available pylons - no pylon can be left unused. Obviously, the empty cells of the field must remain empty.
Each railroad segment must lie on a cycle, as explained below. There can be arbitrarily many cycles. (If there is more than one cycle, each of them will be used as one roller coaster, so it does not matter.)
The longest cycle will be the "flagship" roller coaster. The longer it is, the more people will come to the theme park, so Elly should try to make it as long as possible.

A railroad segment lies on a cycle if we can start on that segment, follow the railroad in one direction through some other cells, and eventually return back to the starting segment from the other direction without ever getting stuck.

You are given a String[] field: a map of the field. Each character in field will be one of {'.', 'S', 'L', 'U', 'R', 'D'}. Here, '.' represents an empty cell and the other letters represent pylons. If there is no valid way of placing railroad segments onto the given pylons, return an empty String[]. Otherwise, return a String[] that describes one valid placement of railroad segments onto pylons by changing each pylon character into the appropriate segment character: '-', '|', '/', or '\'. If there are multiple solutions, find one that maximizes the length of the longest cycle. If there are still multiple solutions, you may return any of them.

Definition

Class:: EllysRollerCoasters
Method:: getPlan
Parameters:: String[]
Returns:: String[]
Method signature:: String[] getPlan(String[] field)
(be sure your method is public)

Constraints

field will contain between 1 and 50 elements, inclusive.
Each element of field will contain between 1 and 50 characters, inclusive.
All elements of field will contain the same number of characters.
Each character in field will be from the set {'.', 'S', 'L', 'U', 'R', 'D'}.

Examples

{"RSSLRD", "SDDSSS", "SULUUS", "ULRLDL", "RLSSRL", "SDUSDL", "SRSLRD", "RSSSSL"}

Returns: {"/--\\/\\", "|/\\|||", "|\\/\\/|", "\\\\/\\//", "//||\\\\", "|//|//", "|\\-/\\\\", "\\----/" }

Remember that in the strings shown in the example output above each backslash is escaped. The actual plan of the railroad looks as follows: /--\/\ |/\||| |\/\/| \\/\// //||\\ |//|// |\-/\\ \----/ There are three cycles. Their lengths are 34, 10, and 4.
{"RDL", "RLL"}

Returns: { }

It is impossible to place the railroad segments onto these pylons in such a way that each segment will lie on a cycle.
{"DSSSSLDSSSDRSSSDDSSDDSSDRDRSSSD", "USLRSUSDSSUSDSLSUSDSSDLSSSRSSDS", "..SS..SS...SS.SSRSUSSSSSSS...SS", "..SS..SS...SS.SSSDSUSSSSSS...SS", "..SS..SS...SS.SSSRSDSULSSS...SS", "..SS..SS...SS.SSUSSUUSSUUL...UL", "..SS..SRSSDSRSLSDSSSSSSSSSSSSSL", "..RU..RSSSURSSSURSSSSSSSSSSSSSU"}

Returns: {"/----\\/---\\/---\\/--\\/--\\/\\/---\\", "\\-\\/-/|/--/|/-\\|\\-\\||/\\|||\\--\\|", "..||..||...||.||/-/|||||||...||", "..||..||...||.|||/-/||||||...||", "..||..||...||.|||\\-\\|\\/|||...||", "..||..||...||.||\\--/\\--/\\/...\\/", "..||..|\\--\\|\\-/|/-------------\\", "..\\/..\\---/\\---/\\-------------/" }

If printed without the escape backslashes the only valid output looks like TCO2017.
{"DD.RSSSL.....DSSLRL.DSSLRL..RLDSD.DSSSSSSD", "SUSU...UDDSSLRSSLSS.UL.RUUSSURU.UDS.DSD.DU", "SRSL.RSSLUL.RDRD.RU..USD.RSSSLRSLSUSLRU.S.", "SS.RSU.DDRL..SSSDLDSSSDRDRL.RUS.RU.RDULRL.", "SRSDRSSUSS.DSURURLRD..UDULRSU.S.RSSLSRLRD.", "SRLSUD..UL.RLDSDDL.RD..SRLRL..S.S.DSUS..RD", "SSSS.S.RSSLDURLSUUDLUL.UU.RUDSL.SDU..S.RLS", "RUSS.S.S.DLSDDRL..RU.UD..RSSU.DLULRD.ULULS", "DSLS.RDRSLRLUURLRL.RDRLRDSDD..RURSURL.S..S", "S.RLRLUD.RURL.RURU.SUUDLSSUU.DD.S.DSL.USSL", "RSU.SS.S.S.RU.DSD..RL.RDSUSSSLRSU.S.DLDL..", "DSSSLRSL.S..DSU.RDDLRDDLS....RD...USLUURSD", "RLDSSSLRSUDDS.DSDSSSRLRDUSSLDLUSSSSL.DL..S", ".SSDDDUS..SSS.RDSULSRSLS.DDSRSDDLRLRDSUSSL", ".RURLUDSRLRLRSDUURLRSLSS.RLRL.SRLRU.UL.DSL", "RSSL.RUSSSRD..RSDRU.DLSS..RDULS.DSSDDL.USU", "SDLRSL.UUSSSRD.DUDDDU.RU.RUUDULRUDDRLS.RSL", "ULSDSSLRSURLRU.SRUUURSSSSL..S..S.SSRSU.ULS", ".RURDRUUL..RSDDLS..RUDSSSSL.RD.S.RUUSDRDSS", ".RSSUS..UL.S.RU.RL.UDRSSSSLDLUSUDSSSSLRUUU", "RL..RLRSLS.RSD.RSURDRSSSDDSUUSSSLRSSDDL.RD", "SRSLSRLRLSDL.S.RL.RLRLDSUUD..RL..RSSLSS.UU", "RSLULUSLRLRL.SDLSRSSUSUSSSU.DUS.DSD.RURL..", ".RLDSDRLRSLRDSUUSUL..RSSSSSSL.UDUDRLRSDUSL", ".RSU.SULRSUSSS.DL.S.DSSSD.RL..RL.SDUDDULDL", "RSSLRURDRD.RUSRUDLRSL.RDULUURSU.DUS.UL.SS.", "USSUSDUS.S.RDSRDSUD.RDUL.SRLS...SRLDD..SUL", ".RSSURLS.RLSSRSUUSL.SS...SULRL..RUDLSDLS.S", ".SDDDSUS.DLUU..DD..RURSSSUDSSURSSLRSUSULRU", ".SSSRSDRDS.RSD.UURLSRD.DSLRLRLS.RU.DSU.RL.", "RUSRSSLDURLULUL..SSSSUSL.S.SUUUSLRDUSL.SDD", "RSL..RLRD.UDS.S.RLRLUD.DDS.S.RSSSLUD.USURL", "DSSSDUL.S..SRDSDU....SDLRL.SDL..DSDUSSSSSL", "UDDSU.RDRSDSRUSRSD.DLSS.DL.ULRSLS.RLRSD.DL", ".UU.RLULDLRURSUDLS.RLUL.SS...SDURL.RLDU.S.", "RDDDSSDDSUSLDSLSSS...RSSLUSDDUS..S.DDRD.RL", "RUUURLULUSSLRSLUUUSSSL.....UL.USSL.UL.USSU"}

Returns: {"/\\./---\\...../--\\/\\./--\\/\\../\\/-\\./------\\", "|\\-/...\\\\/--\\\\--/||.\\\\.\\/\\--/\\/.\\\\|./-\\.//", "|/-\\./--/\\\\.\\\\/\\.\\/..\\-\\./---\\/-\\|\\-///.|.", "||.\\-/./\\//..|||/\\/---\\\\\\\\\\.//|.\\/./\\\\\\//.", "|\\-\\/--/||./-/\\/\\/\\\\..\\\\\\\\\\-/.|./--/|//\\\\.", "|/\\|\\\\..\\/.\\\\/-\\/\\.\\\\..|///\\..|.|./-/|..\\\\", "||||.|./--\\//\\\\|\\//\\\\\\.\\/.\\//-/.|//..|./\\|", "\\/||.|.|.//|/\\\\/..\\/.\\\\../--/./\\\\//\\.\\\\\\/|", "/-/|.\\\\\\-///\\//\\/\\./\\///\\|/\\..\\//-/\\\\.|..|", "|.///\\\\\\.///\\.\\/\\/.|\\///||\\/./\\.|./-/.\\--/", "\\-/.||.|.|.\\/./-\\..\\\\.\\\\|\\---/\\-/.|./\\/\\..", "/---/\\-/.|../-/.\\\\/\\\\\\//|..../\\...\\-/\\/\\-\\", "\\\\/---\\/-//\\|./-\\|||//\\\\\\--\\//\\----\\./\\..|", ".||/\\//|..|||.\\\\|\\/|\\-\\|./\\|\\-\\/\\/\\\\\\|\\--/", ".\\/\\/\\\\|/\\\\/\\-\\\\//\\\\-\\||.\\/\\\\.|\\/\\/.\\/./-\\", "/--\\.//|||/\\..\\-\\\\/.//||../\\\\\\|./--\\/\\.\\-/", "|/\\\\-/.\\/|||/\\.///\\//.\\/.//\\\\\\////\\\\/|./-\\", "\\/|/--\\/-/\\/\\/.|//\\//----/..|..|.||/-/.\\\\|", ".//\\\\//\\\\../-\\//|..///----\\.\\\\.|.\\/\\-\\/\\||", ".\\--/|..\\\\.|.\\/.\\\\.\\\\\\----//\\\\-//----/\\/\\/", "/\\..///-\\|.\\-\\./-//\\\\---\\/-/\\---//--\\/\\./\\", "|\\-\\|////|/\\.|.\\\\.\\//\\/-/\\\\../\\..\\--/||.\\/", "\\-\\\\/\\-///\\/.|/\\|/--/|\\---/.//|./-\\.//\\\\..", ".///-\\/\\\\-\\/\\|\\/|\\\\..\\------/.\\\\\\\\\\\\\\-\\\\-\\", ".\\-/.|\\//-/|||.//.|./---\\./\\..//.|///\\\\\\//", "/--\\///\\\\\\.\\/|///\\\\-/./\\\\\\\\//-/.//|.\\/.||.", "\\--/|//|.|./\\|\\\\|\\\\./\\\\/.|/\\|...|///\\..|\\\\", "./--/\\\\|.\\\\||\\-/\\-/.||...|\\/\\\\..\\///|/\\|.|", ".|/\\/-/|.//\\/../\\..//\\---//--//--\\\\-/|\\///", ".|||\\-\\\\\\|./-\\.\\//\\|/\\./-\\\\\\/\\|.//./-/.//.", "//|\\--///\\\\\\\\\\\\..||||\\-/.|.|\\/\\-//\\\\-\\.|/\\", "\\-/../\\\\\\.\\\\|.|.//\\/\\\\./\\|.|./---/\\\\.\\-/\\/", "/---\\\\/.|..|\\\\|//....|//\\/.|//../-\\\\-----\\", "\\\\/-/./\\\\-\\|//|\\-\\./\\||./\\.\\//-\\|.\\\\/-\\.//", ".\\/./\\\\//\\\\/\\-//\\|.\\/\\/.||...|//\\\\.\\///.|.", "/\\/\\||/\\|\\-\\/-\\|||.../--/\\-\\//|..|./\\\\\\.\\\\", "\\/\\/\\/\\/\\--/\\-/\\/\\---/.....\\/.\\--/.\\/.\\--/" }
{"RLRSSSSSDSDSSSSSSSSL.DLDLDLSDLRDURSDUUDSSSSSSD.RD", "SRU.LRLSUSU.DSSD.DLRLRLUUUUSRLUUDLSUSSLDSSSSDSLUL", "RLRSSLUSSSSSURDULUU.USL.LDSSLDDRLRSSDDDSRL..SSDDD", ".SSRSSLRLRDDDSULUSSL..SSRL..SSUUSRDDUUURUUSSLRLUL", ".RURSSURLRLUURSU.LRUSSL.RSSSLUSSSSUUSSSSSSSSSSUS."}

Returns: { }
{"DL.DL..DD.DDDL", "UU.SSDSUSDLRUS", "RSDUUSDLUL...S", "USLRSLULDDDD.S", "DDRLRLRLRUSRSU", "RLULRUSSDSLRL.", "DL.S..RUSRSUUD", "RLRLRSD.SS.DSL", "DLS.USUDLUDUSL", "SSUSSD.RLDLRSL", "SRLDDSRDUL.RSD", "RSLRLUUUL.DDRU", ".DD..RLRU.RLUD", ".SS.RUULDLRSLS", "RUSDU.RSURL.RU", "S.SUSLRSL.DDRD", "RDS..UL.SDLSSS", "DLRL..S.RU.SUU", "RSSLRLRSSSDSRL", "RSSLUU.DL.ULUL", "UD.S.RSUSDLDD.", ".SRLDU.RUULRU.", ".SRSUDLSDDDLRL", ".RSSSUUURLRUUU"}

Returns: {"/\\./\\../\\./\\/\\", "\\/.||/-/|//\\/|", "/-\\\\/|/\\\\/...|", "\\-//-/\\//\\/\\.|", "/\\///\\/\\\\/|\\-/", "\\/\\\\\\/||/-//\\.", "/\\.|..\\/|/-/\\\\", "\\////-\\.||./-/", "/\\|.\\-///\\\\\\-\\", "||\\--\\.\\\\///-/", "|\\\\/\\|/\\\\/.\\-\\", "\\-/\\/\\/\\\\./\\//", "./\\../\\//.\\/\\\\", ".||.//\\//\\/-\\|", "//|//./-/\\/.\\/", "|.|\\-\\\\-\\./\\/\\", "\\\\|..\\\\.|//|||", "//\\\\..|.\\/.|\\/", "\\--//\\\\---\\|/\\", "/--\\\\/./\\.\\/\\/", "\\\\.|./-/|/\\/\\.", ".|////.//\\/\\/.", ".|\\-//\\|/\\/\\/\\", ".\\---/\\/\\/\\/\\/" }
{"RLDLRLR.", "RLULSRDR", "RSLSULS.", "S.SDLUL.", "SDUSSRL.", "SUSLSULL", "RSSSURL.", ".DSLDUUL", ".USLS..S", "..RDLDSL", "RD.S.SR.", "SUSLRUDD", "RDDDUDSS", ".ULSDLSS", ".URURSLS", "..S.DDDL", "RSLDLRU.", "SDSUDSL.", "SS..S.UD", "SRDSSRSL", "S.USUUDS", "RL....S.", ".RSSSDRL", "RSSSSL.S", "ULDSL.DU", "RLS.UDS.", "ULUSSLS.", "RLDSSSL.", "USLRD.RL", "LRDSUDSS", "DUSRLSUL", "S.USUSRL", "S.S.RLUL", "SRL.SRSD", "RLS.RU.S", "RLSRSL.S", "SUURSUDL", "UDDSDRL.", "RUSSUUU.", "S.RLSDSL", "USDS.USL", "..ULRSD.", "DD.RU.S.", "SUSL..S.", "RSSSSSUL"}

Returns: { }
{".RSSD..", ".S..UL.", "RURD.RL", "RDSRSSL", ".SS.RD.", "DLULSRL", "S.DUSRL", "ULUSUUL", "DU....S", "SRSD.RL", "RLDL.RL", "DDS..DL", "SSRSSU.", "UL....."}

Returns: {"./--\\..", ".|..\\\\.", "///\\.\\\\", "\\\\|\\--/", ".||./\\.", "//\\\\|\\\\", "|.//|//", "\\\\\\-/\\\\", "//....|", "|/-\\.//", "\\///.\\\\", "/\\|..//", "||\\--/.", "\\/....." }
{"RSSSSSSSSSL...DSDU.S.DSSSDDSLRL.DSSD..DL", "USSLDDDSSDUSLURSURSSLRLURLSRLULDU..SDSLS", "RSSURUSRDS..SLDSDRL.SRUDSRLSSL.SDSDULL.S", "RSSSDDSRUUSSL.RLUDS.RSSUSRSUDDDLS.SDSL.S", "RDDDS.UD.DLRSSLRSUSDLRSSU.DDSRLURLSULUSU", "UUULS.SSDLUU.RSRSSUULSDLDSUULDLRSUSDUSSL", "DD..SSDLSSDSSDRURSDDSLSSUSLDLRLS..RDRL.S", "RUDSL.SRUSULDLSDURLRSDSRL.RLSDRURSDULSSS", "DSU...SS..DURL.SURSDRUUSUS.DLRLRLRU..USL", "RSDDSLUL.DUUUUSL.RSLS.DSDDDSDUDL.SRLRLDD", "DSLRSLDLRS.DSDDSDULSRDSDLUUSULRSLSRURLRU", "SRSD.RLUDSSRSLUDS.RSLRLSRSLRDS.USRSSSSL.", "SRLULSDLRLRSLRSLRSLDURSLULUSLSDSU.RSD.SU", "RDSRLSRLDDRDSRSL.RUSDL.RSUDLDLUDRLRDRSLU", ".RLRDS..SS.SUSDSRLDLS.DL..RLSDDSSULSRDRD", "DDSSUUSSUSLUSSUSULUDRLSURL.DUULSUSUSSULS", "DL.DSDDSDSRDRLDU.RLSSRL.SRSUDD.RSSLSRSDS", "SRDS.SS.ULULUURSL.SS.RSSL.RRURDRLDURDDUS", "SRUUSUUD..DSSSSSURUS.S.RSSSL.SSSULDDSUDS", "RSL.RSLSDSL.DDRSDRLRSLDLDSDRL.SSL.ULULSS", "RSUDRLSSSRSSLSSUSRL.DDS.S.RLRLSS.DL..SSS", "SRDRSUSRUS...SS.SUDDLSS.RDDSDSULDUSDSLUU", "SSSRSDUSDSDLRSS.RSLRLSSU.SRSLSRSURRL.UDD", "SSSDDSRDUUSRDSUD...RLSRDURD.SSRSLDDRLRLS", "RLSRUUUSRLSSRUDURDDUDS.RLDLRSL.DLSSSSS.S", "DLS.DDDSULS..DLRLSRSURDSSSDL...UDSSULSRS", "SSULLSSRSDS.DULRSUSD.RLDURU.DSSSUUURLUSU", "SUDUSLSRUSSRL.DDDDULSS.SRSSDRLDD.R.RURSD", "USURSLRSSUSULUSSSUDRLS.SRD.RSURURLRSDS.S", "RDRL.SU.DLRDRLSSUSU.SRSL.SRD.DSSLSSDLRDS", "SSSRSLRLULRS.SSSDSDRUDSD.SRUUSDLDLRL..SS", "SSUU.SSUL..USUSUU.SSDUDL.USSSUSSUSDRSSLS", "SSSDD.RSLDDRSDRLDDSRUDL..S.LD.SSS.SRLDSL", "RLDLUSSSDSSS.RLSULUSDSDL.DSSDRURD.RSLSRL", "DLSRSLDSUSSULRLUDRSDSSULRLRLSSRLUD...RUS", "SSRUUSSDRRURLRSLSS.SSRSDS.RUSULUSL.DSDDL", "SS.DSUSDSLRLDD.RLSLULDLRU.RDSDL.RDRLUSSS", "SS.SSDLSRUUDUU..RLRSSUS.DDSRLRL.UUSSRLRL", "RU.S.RLSSLDLDSSSLDUS.RU.SRULRSDRD.S.SL.S", ".S.RSSUUL.RSL.U.LRSSSU..RSSSU.RURSLSRSSL"}

Returns: { }
{"DD..DSDDSDDSSL....", "UUDSL.ULRLUD.ULRSL", "RSURL..RU..SRLSSDL", "S..SSDSU.RLUURUUL.", "RSDUUUSD.RL..RSL..", ".DLDDDLS.RSSLS.RL.", ".RSUSRLS.S.RLSDDRD", "DSD.USSU.RLSRUSSRL", "ULRSSDRSSSUUU.SSRD", ".RLDLSRL....DDUUDL", "RLSULRLUSSSSLS..UD", "SSRLDDSDL...DUDSSL", "SUSLULSRLDL.USU.DL", "RDRSSSL..RU.RLRLRL", "RLSRLRSLDSL.RLSUSD", "USURLUSLRDSDSDS..S", "DL..DSSL.RUSDUS.RL", "UL.DUDLSDSDRL.ULUD", ".DSL.UUSSDUDD..RSU", ".S..DD.RLS.SRSL.DD", ".SRDSS.DDRSLDLRLRU", ".RUSUU.UURSDRU.SDL", "...S.....RSLRSLSRL", ".RDS.DSL.DL.RSUSRD", ".RLSDL.RDSRSSSSURU", "RD.SSDD.RLRSSLDDDD", "SS.RLRURL.RD.SRURU", "SSRSLRLRURDULSRSL.", "UUUSURU..RU.ULRSL."}

Returns: {"/\\../-\\/-\\/--\\....", "\\//-/.\\///\\\\.\\\\/-\\", "/-//\\..//..|/\\||//", "|..||/-/./\\\\/\\/\\/.", "\\-\\\\/\\-\\.\\/../-\\..", ".///\\/\\|./--\\|.\\\\.", ".\\-/|\\/|.|.//|/\\\\\\", "/-\\.\\--/.\\\\|//||//", "\\\\\\--\\/---/\\/.||\\\\", ".\\\\/\\|\\\\..../\\\\///", "/\\|\\/\\\\\\----/|..\\\\", "||\\\\/\\|/\\...///--/", "|\\-/\\/|\\//\\.\\-/./\\", "\\\\/---/..\\/./\\/\\\\/", "//|/\\/-\\/-\\.\\/|\\-\\", "\\-/\\/\\-/\\\\|/-\\|..|", "/\\../--\\.\\/|//|.//", "\\/.///\\|/-\\\\/.\\\\\\\\", "./-/.\\/||///\\..\\-/", ".|../\\.\\/|.|\\-\\./\\", ".|/\\||./\\\\-//\\\\\\\\/", ".\\/|\\/.\\//-\\\\/.|/\\", "...|.....\\-//-\\|\\/", "./\\|./-\\./\\.\\-/|/\\", ".\\/|//.\\\\|\\----/\\/", "/\\.||/\\.\\//--\\/\\/\\", "||.\\/\\//\\.\\\\.|\\/\\/", "||/-\\/\\\\//\\\\\\|/-\\.", "\\/\\-/\\/..\\/.\\/\\-/." }
{"DD.DSD.DD.DLDDRSL...RL", "SRDS.S.RUDLSRLS.S.DLSS", "RSLSRLRDDL.UL.RLRSLSSS", ".DSUS.SSRDDDS..S..RUSS", "DURSU.ULDLSSSRLSDDS.SS", "S.RL...DLDLSRLSSRLUSLS", "S..RLDSL.USU.DUS..DL.S", "S.RDSSDD..DLRLRLDDUUDU", "S.RUUUULRLRUUDRDSS..UL", "UD.RSLRLUL.RLSRLSS.DLS", ".S.USUUUDSDSSRLDURDSUU", ".S.DSSL.S.RLRD.S.SSRSL", ".SDLDSL.UD.RLS.UL.USSU", "DLS.RSL..SRUUUDLUSL.RL", "S.UL..S.DUUL..SSRDULSS", "S..SDLS.RSDUD.UUUL.SUL", "SDSLSSRSSLRSL.DL.DLS..", "SRDRLS...RSSSLSS.SSRSL", "SRLS.SRD..RLDLUU.SUSDS", "SSRLRUSRSDRURDDDDL.RUS", "UUULSRURLS.RLRUSSRLUSU", ".DDSRL.RUULRUDSLSUURD.", "DUSSDD....USLUL.USLSS.", "RDSULUSSSD.DL.S..RURL.", ".ULDSSSSDS.S..SDSUDL..", "RSDUDRL.SS.S.DUS.RLRL.", "S.SDLRU.SUSL.S.USU..UL", "S.SSDL.DL.DD.RDRSD.DDS", "S.RLRU.USSUS.RLRDRLUUS", "USDDSSSSSSSLDLRLRSU.DU", "DDUUDDDSDDSSL.SUSD.DU.", "SSDLRUS.SSDD..UL.S.RD.", "SSSSRSURUSULDD.S.SRSU.", "ULRLRD.S.USSLUDUSURSD.", "DSSSSLDLDDDSD.RSSSL.S.", "S.RL..RLUUS.RSDRSSL.RD", "ULRLDSLRLDL...RLDSSSLS", ".SDLULRLRUDSSD.RL.RDUL", "DUULDU.SDLS..RDRSDSUD.", "USSLS.DLSSSDD.SRDSRDS.", "DD.UU.S.SSRLSDUULUDRL.", "SUDDSLUDUL..RL..RDRSSD", "RSUUSU.USSSSSSSSUUSSSL"}

Returns: { }
{"DSSL..DSSD", "UD.UL.S.DL", ".S.DLDL.RL", ".RLS.S.RSU", "RSLRLUDSRD", "S...S.UUUL", "SRSSLRSSD.", "SUSLDLRSL.", "S..SRSUDD.", "SRLRSDDLS.", "ULS..UL.S.", "DDRSLRD.RD", "UL.DURL..S", "DSLRSSLDSL", "USL.DLSUD.", "DD..ULRLUL", "SS.RSSDRDS", "RU.RL.S.RL", "....UDRD..", "RLDSDS.SRL", "ULULUUDURL", ".RSL.RURSD", ".SDLRL.UDS", ".SSSS.RLSS", ".SRLRSUSSS", ".SRSDRLSUL", ".ULRUULUD.", "...SRSD.RD", "DL.SUSU.DU", "RURUDSSSU.", "DSU.S..RSL", "S...UL.SDU", "RSSSLUSURD", "DSSLS....S", "USDSUSDRSU", "DLRL..UL..", "SS.DD..DSD", "SSDURD.ULS", "SRLDDSRSLS", "UDRLSSRSSL", ".SSDUSDSSL", "RLUUDLS.RL", "S.DDRLRLRL", "RSLUSL.S.S", "RLRDRLRL.S", "ULSRURUDDS", "DLSRSSSUSS", "RLUL....RU"}

Returns: {"/--\\../--\\", "\\\\.\\\\.|.//", ".|.////.\\\\", ".\\\\|.|./-/", "/-/\\\\\\\\|/\\", "|...|.\\/\\/", "|/--//--\\.", "|\\-\\///-/.", "|..|\\-//\\.", "|/\\\\-\\//|.", "\\/|..\\/.|.", "/\\\\-\\/\\.\\\\", "\\/.//\\/..|", "/-\\\\--\\/-/", "\\-/./\\|\\\\.", "/\\..\\/\\\\\\\\", "||./--\\\\\\|", "\\/.\\\\.|.\\/", "....\\\\\\\\..", "/\\/-\\|.|/\\", "\\/\\\\\\///\\/", "./-/.///-\\", ".|/\\//.\\\\|", ".||||./\\||", ".|\\/\\-/|||", ".|/-\\/\\|\\/", ".\\///\\/\\\\.", "...|/-\\.\\\\", "/\\.|\\-/.//", "\\////---/.", "/-/.|../-\\", "|...\\\\.|//", "\\---\\\\-/\\\\", "/--\\|....|", "\\-\\|\\-\\/-/", "/\\\\/..\\/..", "||./\\../-\\", "||//\\\\.\\\\|", "|\\//\\|/-/|", "\\\\//||\\--/", ".||//|/--\\", "//\\///|.//", "|./\\\\\\\\\\\\\\", "\\-/\\-/.|.|", "/\\/\\/\\//.|", "\\/|\\/\\//\\|", "/\\|/---/||", "\\/\\/....\\/" }
{"DSD..DSLRSDRLDLRD....DDDLRSSSSDDSSSDRSL", "S.UD.RLULDURLULSSRSSLRLULUSLDSLS.RDSRLS", "RD.USDRLDL.....RLUSSL.DSSSSLS.DU.SRL.SS", ".S...UDSSRSD.DSSSSLDSDS.DL.DU.SRSURL.UU", ".SDSLDUSSRSL.RSDDDSS.SS.UL.S..SS..ULDL.", "DLS.SULSUL.....RUULUSLS....USLSUSSDRLS.", "S.ULRLRL.RSSD.DSL..DDRS.DSSSDUL.RLSRSL.", "RL.SDLDSSLRDRDSRUDLSS.RDSRL.S...SSS.RL.", ".USLRSU..RURSUUL.RUUL..RUUL.RSSSUUU.UU."}

Returns: { }
{".RSSSDDSD......RSD..RD.DDDDRSSDDSSSSSD..", ".UL.DUSDLRSSSL.RSLDLSULULRLS.DLRD.RSDSRD", "..USU.SSRUDSDRSSLDLSRLSRLDLULUSSL.RDSSUL", "DLDSSDSUU.USUDD.RU.RLSUURUUDULDLRSDRUSDL", "UUSRLULRSDDD.ULRL...SUSSDDSU.SRLS.RL.SUU", "..SUL..USUSRLDLSRL..S.DDSSDD.UD.S..RLSDL", "DLSRSD...DUDURUULSRSL.ULUUUU..UDRSL.SSUL", "SUUSRU.RSURU..DSUUU...RSSSLDSSSLRDRDUURL", "S.DUSDDS.DU..DLDSSSSDDL.RSLS...RLRSL..RL", "S.RSURUSDU..RL.SRDRLUURSL..USSDUSSD..DSL", "SRSSSSSUS.DDRSDSRLRL.RL.RSL..DUDL.S.RL.S", "RL.RSSSLUDUUDDSULDSD.SRLRDRSSU.RL.ULSRSU", ".DDUL.RU.SRSUSULSS.S.SRL.S.DD.RSSSSLUU..", "DUULUDS..SS..USURU.S.USSSLRURSU.RL.DLRD.", "RSLRSUSDSUSRSLDSSSSU..RD.RU.RSSSUUDUUSS.", "DSU.RLSRSSURSLS...RLRLUU.RLDLRSSSDUL.RU.", "RLDDSUURD..RD.RL..RLUL.RD.UUDURSDS.USSSD", "DUULS..UUDDRL..RSLRDRSLUUDSSL.S.UUDLDD.S", "USL.RSLRLSRSLDSSSUSSS.USDUL.DLSDL.RLULRL", "..SDDRUSSS..UL....RLS..RL.S.ULULUSL...S.", ".RURLSDURLRSLRSSSL..SRSURSLDLDSD.DU.DLS.", ".SRSSLRSSDS.UURL.SRDRURLSRLRLS.RDUSLSUU.", "RLUSD.RDDLSRL.RU.SUURLULSRL..RSDSRDSRSSD", "S.DLUDRUS.SSUDDSDUD.RLDSU..DSDDLSULRSSLS", "RLUL.UL.RLSUDSS.USL.RDS..DSURLUDUSSSSDUL", ".ULRSDS..SS.SSUSSD..SSRSDS.RURLS.DDRSU..", ".DLULUL.RUS.RU...UDRLRLRUSDU.UURSLSSDSSL", ".RSSUDSDUDRDRSSLDSLUD.RL.SRSSSLRSSUSSRDS", "RSSSDS.S.RSLS.DLS.DDUD.DSL.RL.SUDDSLSRLS", "ULRSLRLRSD..SRU.S.ULRU.RDRLRU.SDLS..RL.S", ".SUSD.SDSUDSLRD.RSL.RSL.SUL.RDRL.USL.SRL", "DLRLRDSSDSU.RLRSSLSDD.RDS.DDRUDDDDRU.SS.", "RDSSDUSUURSLSUD..RUSUL.SSDLRDDURURU..UL.", ".RLULDL.DU.SRSLDSSDUSLDLULDLSSRSL..RDRD.", "..RSDSRSLRLRDDLS..UD..SRSDULSSS.RD.ULSUL", "..S.RURSDSS.RURL.RDUSSUULS.DLUL.DL...SDU", "RSL.DDDLSSS..DDDDSSDSL..RLDL.DSLSRDRLSUD", "SRSLSSRUUURSLULRUUUUSL.DD.RSDSDLSULULSRU", "UL.SRU.RLDSSU.RL.RSLRL.UU...RLSDURDDSUUD", "...RD..SSSRSSDRLRUDLRU.DSSSSSDSSDLRL...S", "RSL.USDRUUURSU..RLSRDDLRLDSSSLRLRD.RL.RL", "SRUDD.USSSSL.RLRSUSULSUSLUSSSSSSDRSURSU.", "RL.UURSSLRLDDSSSDLUSLSRD.RSD.DSLSDSSSLRL", "RLDD.S..SULSSSSSSUD.SUUS.S.RSLRUSRSSDSUU", "ULSUDRSSUDLUUULSULUDSRSLDLDSL.SRU.RLRUDL", "DLRDRLRDRUSRDRLS.SRUSUSSU.S.SRLSDDRURLSS", "UL.RSLULUSLULUUUSLUSL.....USLRSLRL..UURL"}

Returns: {"./---\\/-\\....../-\\../\\./\\/\\/--\\/-----\\..", ".\\\\.//|///---\\.\\-//\\|\\\\\\/\\/|.//\\\\./-\\|/\\", "..\\-/.||///-\\\\--\\//|\\\\|/\\/\\\\\\\\--/.\\\\||\\/", "/\\/--\\|\\/.\\-//\\.\\/.\\\\|\\/\\/\\\\\\\\/\\/-\\\\/|/\\", "\\/|/\\\\//-\\/\\.\\//\\...|\\--\\/-/.|\\/|.\\\\.|\\/", "..|\\/..\\-/|\\\\/\\|\\\\..|./\\||/\\.\\\\.|..\\\\|/\\", "/\\|/-\\...////\\/\\\\|/-/.\\/\\/\\/..\\\\\\-\\.||\\/", "|\\/|//./-///../-/\\/.../---\\/---//\\\\\\\\//\\", "|.//|/\\|.//..///----\\//./-/|...//\\-/..\\/", "|.\\-/\\/|//..//.|/\\/\\\\//-/..\\--\\\\--\\../-\\", "|/-----/|./\\\\-\\|\\/\\/.//./-\\..///\\.|.//.|", "\\/./---\\\\\\\\//\\|\\\\/-\\.|/\\\\\\\\--/.\\/.\\\\|/-/", "./\\\\\\.//.|/-/|\\\\||.|.|\\/.|./\\./----/\\/..", "//\\\\\\\\|..||..\\-/\\/.|.\\---///\\-/./\\./\\/\\.", "\\-\\\\-/|/-/|/-\\/----/../\\.//./---/\\\\\\/||.", "/-/./\\|\\--/\\-/|.../\\/\\\\/.\\\\///---\\\\\\.\\/.", "\\\\/\\|\\//\\../\\.\\\\..\\/\\/./\\.\\////-\\|.\\---\\", "//\\/|..\\//\\\\/..\\-\\/\\/-\\\\//--/.|.\\//\\/\\.|", "\\-\\.\\-\\/\\|\\-\\/---/|||.\\-\\\\\\./\\|/\\.\\/\\///", "..|/\\//|||..\\/....\\/|..//.|.\\/\\/\\-\\...|.", ".//\\/|//\\//-\\/---\\..|/-//-//\\/-\\.//./\\|.", ".|/--/\\--\\|.\\//\\.|/\\\\//\\|/\\\\/|.\\\\\\-\\|\\/.", "//\\-\\./\\//|/\\.\\/.|\\//\\\\/|\\/..\\-\\|/\\|\\--\\", "|./\\\\\\\\/|.||\\\\/-\\\\\\.\\//-/../-\\//|\\/\\--\\|", "\\\\\\/.\\\\.\\\\|\\\\||.\\-/./\\|../-///\\\\\\----\\\\/", ".\\\\/-\\|..||.||\\--\\..||\\-\\|.///\\|./\\/-/..", ".//\\\\\\/.//|.\\/...\\\\//\\\\//|//.\\/\\-/||/--\\", ".\\--//-\\\\\\\\\\/--\\/-/\\\\.\\/.|\\---\\/--/||/\\|", "/---\\|.|.\\-/|.//|./\\\\\\./-/./\\.|\\\\/-/|\\/|", "\\\\/-/\\\\\\-\\..|//.|.\\///.\\\\/\\\\/.|//|..\\\\.|", ".|\\-\\.|/-//-/\\\\.\\-\\.\\-\\.|\\/./\\\\/.\\-\\.|//", "///\\\\\\||/-/./\\\\--\\|/\\.\\\\|./\\\\//\\/\\//.||.", "\\\\||//|\\//-\\|\\\\..\\/|\\\\.||//\\\\//\\/\\/..\\/.", ".\\/\\///.//.|\\-//--\\\\-///\\//\\||/-\\../\\/\\.", "../-\\|/-//\\\\\\/\\|..\\\\..|/-\\\\/|||.\\\\.\\/|\\\\", "..|.\\/\\-\\||.\\/\\/./\\\\--/\\\\|.//\\/.//...|//", "/-/./\\/\\|||../\\/\\||/-\\..\\///./-\\|/\\/\\|\\\\", "|/-\\||\\/\\/\\-\\\\/\\/\\/\\-/./\\.\\-\\|//|\\/\\/|//", "\\/.|\\/./\\/--/./\\./-\\/\\.\\/...\\/|///\\/-/\\\\", "...\\\\..|||/--\\\\/////\\/./-----\\||//\\/...|", "/-\\.\\-\\\\/\\//-/..\\\\|/\\/\\\\\\/---/\\/\\\\./\\.//", "|///\\.\\----/./\\/-/|\\/|\\-/\\------\\\\-/\\-/.", "\\/.\\//--\\/\\/\\|||/\\\\-\\|/\\./-\\./-\\|/---\\/\\", "/\\/\\.|..|\\/||||||\\\\.|\\/|.|.\\-///|\\--\\|\\/", "\\/|\\\\\\--//\\\\/\\/|\\\\\\\\|/-////-\\.|//./\\\\//\\", "/\\\\\\\\\\/\\//|/\\/\\|.|//|\\--/.|.|//|/\\\\//\\||", "\\/.\\-/\\/\\-/\\/\\/\\-/\\-/.....\\-/\\-/\\/..\\/\\/" }
{"....RD", "DSL.SS", "ULSDSS", "DUS.SS", "SRU.SS", "SUSLSS", "RSDULS", "DSU..S", "USSSSL", "RL....", "SUD.RL", "RLSRUS", ".SUL.S", ".SDSSL", "DUSDSL", "S.UUDU", "USSLS.", "..RUS.", ".RU.S.", ".SDLS.", ".SSRL.", ".UL.RL", "DSSDUL", "S..SRL", "UL.SSS", ".S.SUU", "DL.S..", "SDLRD.", "SSS.RD", "UUUSSU"}

Returns: { }
{"DSLRSSSSSSSSSSSSD....DDDSD", "ULUU....DD......RL.DLRURSU", ".S...DSSLRL.RSLDDS.SUDRLDL", ".USL.RLDSDS.S.UUSUDSDURLSS", "DD.SDSUUSLS.UL..SDURUDD.UL", "RU.SS..RL.S..RLRLRD.RLRSL.", ".DLSUSSLRSUDSDUU.DLDLRD.UD", ".SSSRLRSD.DU.SDSDS.RLSS..S", ".SSUURU.UDSRLSS.SRL.UURD.S", ".SRDRDRSLUURUSS.S.RL...S.S", "RU.RURL.UD...UL.UDDURLDURL", "RLRD.RDDLRL.RD...SRLSRUDU.", "RUSS.SRUS.UDSRSL.USLUSDSDL", "S.RU.USLS..SSRLUSSD.DLSUUS", "S.DD.RDSUSSLSRU.DDULRUS.DU", "SRLUDRLSRDDSLDSSLSRL.DU.UD", "SRD.RSSLRLRSDS.RLSS..RSLDU", "SRUDLRDRSSSDUL.SSSSRSSSUS.", "SS.ULSSS..DLRSLULSSRSDRSU.", "SULDSLSRSDUDUSL..UL..SS.DD", "RSUSRSURLRSURLRL.DDDSLUSUS", "...RL..RURL.ULRURLRURSSD.S", ".RSL.RSSLRU.DSSSU...S..SDU", ".UDS.S..USD.RD.DSL..RSSUS.", "RDSSRU.RSDUSDS.S.UD..RL.S.", "SSSSRDRLRLDDUL.SDLS.RLS.RD", "RUSS.SRLSDUUD..SRLRSL.USLS", "RLSRSL.SSSDSLDSUDSSSL...RU", "SSSDD.DUUURSSL.RU...SRSSSL", "RLRUS.SRL.RDDD.RSSD.SUD..S", "RLDDRSUSS.RLRU....RSU.SDSL", "ULUL.RSLUD..RDRLDSD...SSDL", ".....S...USSLUUSS.RSSDRLSS", ".DL..RDRSSD..RDRLRSD.SDDUU", ".SSRL.SUDDURSUUSLUDSRUUL..", "RUSSS.SRUS.S..RLS.UURSSSD.", "S.UUS.UL.RLUSLULSDLDD.DDRD", "RLDLRD....USLRD.SSSUURUUDS", ".UUUSL.DL.RSU.USUSSDSLDDSS", "DD.....UU.RLRDDSSUSUDRUSUU", "ULDSD.DSSLRUSSUSDRL.SUSU..", ".DL.S.RL.SUSUSRSLS..USL.DL", "RL..UD.S.SRSSUSRSLRSSDRSUS", "USSSSLDL.UUDSDUL..UL.RSSSL", "......USSSSL.RSSSSSU......"}

Returns: {"/-\\/------------\\..../\\/-\\", "\\\\\\/..../\\......\\\\./\\\\/\\-/", ".|.../--/\\\\./-\\/\\|.|\\\\/\\/\\", ".\\-\\.\\\\/-\\|.|.\\/|\\\\|//\\/||", "/\\.|/-/\\-/|.\\\\..|//\\//\\.\\/", "\\/.||../\\.|..\\\\//\\\\.//\\-\\.", "./\\|\\--/\\-//-\\\\/./////\\.\\\\", ".|||/\\/-\\.//.|/-\\|.\\\\||..|", ".||\\/\\/.\\\\|/\\||.|\\\\.\\/\\\\.|", ".|\\\\/\\/-\\\\/\\/||.|.\\\\...|.|", "//.\\/\\/.\\\\...\\/.\\\\///\\////", "\\\\/\\./\\/\\\\\\./\\...|\\\\|\\///.", "//||.|\\/|.\\\\|\\-\\.\\-/\\-\\|/\\", "|.\\/.\\-\\|..||/\\\\--\\./\\|\\/|", "|./\\./\\|\\--/|\\/./\\\\\\\\/|.//", "|//\\\\\\/|/\\/-//--/|//.//.\\\\", "|\\\\.\\--/\\/\\-\\|./\\||..\\-\\//", "|///\\/\\/---\\\\/.||||/---/|.", "||.\\/|||..///-\\\\/||\\-\\/-/.", "|\\\\/-/|\\-\\\\\\\\-/..\\/..||./\\", "\\-/|/-//\\\\-//\\/\\./\\/-/\\-/|", "...\\/..\\//\\.\\/\\///\\//--\\.|", "./-\\./--\\\\/./---/...|..|//", ".\\\\|.|..\\-\\.\\\\./-\\..\\--/|.", "/\\||//./-\\\\-\\|.|.\\\\../\\.|.", "||||\\\\/////\\\\/.|/\\|.//|.\\\\", "\\/||.|\\\\|//\\\\..|\\/\\-/.\\-\\|", "/\\|\\-/.|||/-//-//---\\...\\/", "|||/\\.//\\/\\--/.//...|/---\\", "\\/\\/|.|/\\./\\/\\.\\--\\.|\\\\..|", "/\\/\\\\-/||.\\/\\/....\\-/.|/-/", "\\/\\/./-/\\\\../\\/\\/-\\...||/\\", ".....|...\\--/\\/||.\\--\\\\/||", "./\\..\\\\/--\\../\\\\//-\\.|/\\\\/", ".||/\\.|\\\\///-/\\-\\\\\\|//\\/..", "//|||.|//|.|../\\|.\\/\\---\\.", "|.\\/|.\\/.\\\\\\-\\\\/|/\\/\\./\\\\\\", "\\\\/\\\\\\....\\-\\\\\\.|||\\///\\\\|", ".\\/\\-/./\\./-/.\\-/||/-//\\||", "/\\.....\\/.\\\\/\\/--/|\\\\//|\\/", "\\//-\\./--\\//||\\-\\//.|\\-/..", ".//.|.\\\\.|\\-/|/-/|..\\-\\./\\", "//..\\\\.|.|/--/|/-//--\\\\-/|", "\\----///.\\//-\\\\/..\\\\.\\---/", "......\\----/.\\-----/......" }
{"..RSL..RDRSLRDDSSSL...DSDRSSSD.DSLDDDSLRDDSD", "DSURURSLRL.RLULDD.S.DDUDSS..RU.SDURLRDSSSRLS", "RL.USURL...RSSSUS.RDRL.ULRSSURSLSDSL.RLSRSLS", ".RSD..SS.DDRDRLDUDLUL.RDRDDSSU..RL.S...SRL.S", "DL.S.DUUSUSDLSRL.RU.UDSUUUU....DL.RU.DSURU.S", "RUDL.SDD..RU.S.RL.RSSUS..DSSDRDSS.RSSUDLRD.S", "..S..RURLDSDRU.SRSL...S.RLDDSRLRUDD.DDSUUSRL", "RLS.RSSSUS.SS..USL.RSSL.S.UURLDDRLRDRURDRUS.", "SSS.USL..USUUSSD.ULRL...UL.RSLRLRSDUSLDLSDU.", "SSUSSSLRL..RLRLRSLS.USLDSU.RD.....SRLRURLUSD", "SUSSSSLSUSDSSUL..SSDD.SRSSD.SDLRLDLULDDRSDDL", "S..RL.SSRDUURSL.RLSSS.USSSLDLSSRLRSSSLUDDUS.", "UL.RLRLSRURDRSURL.RUULDSSSSU.RURLDD....RL.S.", "RU..RU.SRDULS..USL...RL.RL...DSLSSUSDRSL..RD", "S...SRDSUU.DLRSSLUDRD...RLRSLUDRURSDSSDUDL.S", "RSSLSULUDDDRSLDDRDSULDSLDLUSU.RL.RSUSSUSLUSL", "RSDRL.DSLRL.RDUU.SS.DU.RURDDD..DLSRSUSDSSLDL", "UDS...S..RSSURLRDSSDLDSSSDSRLDSURURL.UURSUUU", ".SRDRLRD.S.RL.RLULSS.S...SRL.S..RSDSDSSU.DD.", ".SRLSS.S.S.RU.....ULDU.RDUDS.UD.SDLUURLRLSRD", ".SS.UURU.S..RDRSSD..USDSUDRL.DUDLUD..RUSSUSU", ".SS..DUDSLDDULSDDRSL..SRLS..DU.SDLUDDSSLSRL.", ".RUDSL.ULDUSRDSSUSLSRSUDURLDUDSUSS.RL.RSUUU.", "DSSL.DDRURDSRLSRSDRUUDRU.RLUDUSSUSDD.RLRSDDD", "S....SSSRDSSDDRL.SRSDRURSLDDRSSLRUSS.SDL.SUL", "S.RSSLRURURURLDL.SULUDDU..RLDSSLS.UURUSDSUDD", "RLRSSDRLDLRLDLSRDS.RSLUD.DDRL...SRDRU.SUSDRL", ".SRD.SULUUSULUURLSDD...USLSS..DLSRURLRU..S..", "RUULDU..RDS....RLRURSSD.RDRURDULRL..RURL.SDL", "UL.DUDD.SRL.DL.SRSLDL.USUS.RLSRSDRSLDSLRSUSS", ".UDUSLSRL...UU.S.RUSSDDRSU.RLSUSU.SSUSD.DSLS", "DDRSL.SUSSD..RSLDUDUSULRSD..SRSSDDLSDDULS.DL", "SUD.S.RSL.SRLRSLS.S.S..RLUSLRL..SRLSUL.SRDS.", "S.RDS...SRUSUSLRUDL.RL.ULDSLRLDSL.RL...USLS.", "RSLUUDL.SSDU..USSL.DDSDSSURLUDUDRSLRSSD.DSL.", "..S..ULRUULDSSSLDSLRLUU.DDRU.SRLUL.SDDRLS.DD", "RSL.DSDSRL.USLRUUDSRSSSDSS.RDSSRDUSUUUDLUDRU", "SRSDUSLSUU..DLSRLULS...ULRDULRLRLRLDLRLRSURD", "RU.USSSL....USURU..USSSSSSU......UUULUSL..UU"}

Returns: { }
{"DD..DSLDLDSSDRSDRDRDDL..", "SSRDRLSULRSSUS.SRURLUURD", "SSRU.ULDSSLRSU.RD...DDUL", "RU.DSSSL..UU....SRSLRL..", "RSSU.RSDRSSSSSSSLUSU.RD.", "SRDRDS.SS...RL.RSLRSLSRL", "UUSUURSURSSSUULRSUS.SUSL", "..SDDDL....RL.RDRDS.SDSD", "RSLRUULRSD.SRSSLULRSLRSU", "SRLDL..S.UDS.RSSSSD...DL", "SRLRLDSL..SS.SDSD.S.DLRL", "RSSL.RSSDRUS.SRSL.S.SRSL", "DSDS...DLULULSRLDDRLUD.S", "S.SRSL.SRLUDSSSSRLRU.USU", "USU..USUUU.RURLUSSU....."}

Returns: {"/\\../-\\/\\/--\\/-\\/\\/\\/\\..", "||/\\\\\\|\\/\\--/|.|\\/\\/\\//\\", "||\\/.\\//--\\/-/.\\\\.../\\\\/", "\\/./---/..\\/....|/-\\\\/..", "/--/./-\\/-------/\\-/./\\.", "|/\\/\\|.||.../\\./-\\/-\\|\\\\", "\\/|\\/\\-/\\---/\\\\\\-/|.|\\-/", "..|/\\/\\..../\\.\\\\/\\|.|/-\\", "/-/\\/\\//-\\.|\\--/\\/\\-/\\-/", "|/\\/\\..|.\\\\|./----\\.../\\", "|\\/\\//-/..||.|/-\\.|./\\\\/", "\\--\\.\\--\\//|.|\\-/.|.|\\-\\", "/-\\|...//\\\\\\\\|/\\/\\\\\\\\\\.|", "|.|\\-\\.|/\\\\\\||||\\///.\\-/", "\\-/..\\-/\\/.\\/\\/\\--/....." }
{"RL....DDDL...", "SRSLRSUSRURSD", "S..RLDSURDRSL", "SDSLDL.DURDDL", "SS.RUDSURSLSS", "SUDRDUSSU..SS", "RSUSS.RL.RDSS", "...UL.UU.RURU", "DSSD.DDDDDLDD", "SRLS.RURLSSUL", "SSSUSD.DDSSRD", "SUL..RLSSULUU", "USSDDLSULRDDD", ".RDRUSRSSLSSS", "DLSRLUSSSLSSS", "SDSRUDDRSURLS", "S.S..UURSSL.S", "S.ULRSD.RDRSL", "USLSS.RSLS.DL", ".RLSRSSD.S.SS", ".RLUSSDS.RSUS", "..SRSLRLRSSLS", "RLRUDLDDS.RLS", "RLRDSRLSS.RSU", "..RUSRSUUSSL.", ".DDDLRL.RL.S.", ".RLUSUS.RL.S.", "RD....RDRL.S.", "SSDSL..SRURU.", "ULS.USLUD.SRL", "DSU...RLS.UUS", "S...DSDSUSSSL", "RSSSU.UU....."}

Returns: { }
{".DD..DSSSSSLRL...DLRDRLRSSD....RD.RSSL", ".SRSDRSD.RLUUSDD.RURURUS..USSSSUULRSSL", "DLRLSDDUSLSDDSSSRDRSSSSURL.DSSLRSU.RSD", "S.SUUSUSSSLSRUSSULSDSSL.ULRU.DLRD..RSL", "S.USLSRL.RSLRLSRLDLUSDSRSDRDRLDDS.DLDD", "S.RLRURL.S..ULRSLSRL.ULRSL.UU.ULULRLSS", "RLSULDDRSUDD..DSLSUURSSSSD.RSSD..RSDSS", ".UL.SUURSLULRDUSLUSDS.DSSLDL.RU.RSSLSS", "..DSURSD.SRSURL.DSSUS.USSSU..SDLS.RDSS", "RLSDLS.RLSS...S.RSSDRSSD.DSD.RLSS.ULSS", "ULRLSS..SRUDSSLDSD.S...SRLDUDSLSS...UU", "DD.DLULDUDSL.DDS.S.UD.RUSRL.USUSRSD.RD", "RL.S..SUSLDLDUSRSL..RDUDUUDSDRSL.RU.RU", "DD.S.RLRL.RUS.ULRSDRLRSURDS.SRD.DU.RSD", "UL.RSL.UU...RSSLUSUUU...UUUSL.USU..USL"}

Returns: {"./\\../-----\\/\\.../\\/\\/\\/--\\..../\\./--\\", ".|\\-\\\\-\\./\\\\/|/\\.\\/\\/\\/|..\\----/\\\\\\--/", "///\\|/\\\\-/|/\\|||/\\/----//\\./--\\/-/./-\\", "|.|\\/|\\---/|\\/||\\/|/--\\.\\///.//\\\\..\\-/", "|.\\-\\|/\\./-//\\|\\\\//\\-\\|/-\\\\\\///\\|./\\/\\", "|./\\\\/\\/.|..\\/\\-/|/\\.\\/\\-/.\\/.\\/\\\\\\/||", "\\\\|\\\\/\\/-//\\../-\\|\\//----\\./--\\..\\-\\||", ".\\/.|\\/\\-\\\\//\\\\-/\\-\\|./--///.//./--/||", "../-//-\\.|/-/\\\\./--/|.\\---/..|/\\|./\\||", "/\\|/\\|.\\\\||...|.\\--\\\\--\\./-\\.\\/||.\\/||", "\\/\\/||..|\\//--//-\\.|...|/////-\\||...\\/", "/\\.//\\\\///-/./\\|.|.\\\\.//|//.\\-/|\\-\\./\\", "\\/.|..|\\-//\\//|\\-/..\\\\\\\\\\//-\\/-/.//.\\/", "/\\.|.///\\.\\/|.\\\\/-\\/\\\\-//\\|.|\\\\.//./-\\", "\\/.\\-/.\\/...\\--/\\-/\\/...\\/\\-/.\\-/..\\-/" }
{"DD.RSSSDRLRSSSDDSDDSSD.", "SRDRLRLSSSUSSDRU.SRSSL.", "USU.RURUSSDD.SDD.RD.DD.", ".DSSL.DLSULS.RLUL.ULUL.", ".RL.SDLRLDSU.DSLRSSU.RL", "DSL.SS..DU.DSUDURL...RL", "USSLSRL.ULDL.RLRLUL..RL", "RSSUS.S.DUUSLUDS..USDRL", "S.DSU.S.RDRDS.UL.DSLUD.", "RSLDSSL.DLSSS..RLUDUSL.", "...S....RLRLUSLUU.SDLDL", "DL.USSLRDS.RD.USSSURUSS", "RU..DSURUS.RU..RDDLRLSS", "DDRDUDDL.S.DLRSUSRLULUL", "SUUS.SSS.SDUSUSSL.DSSL.", "SRLS.RUSDLSDURDRSSL..S.", "UUSRLDSURDRLDLRU..DSSL.", "DDSRLS.RDUSLRLRSSSL....", "RUSULRSUSDDS.SSDSSDRSSD", "..S.UD..ULUL.SSRSDSSDSU", "RDSDLUDRL.RSSLS..SUUSRD", "SULUL.SULDU...USDUSDSSS", "SRL.DSLRSUDSSLRLSDSLSUU", "SSRSL.RU..S..SUUUURSLRD", "SUDRL.UDDSU.RU....SDLRL", "RSURLDLSSDL.SDLDLDURU..", ".....RLSUURSLSSSUURSDDL", ".DLRSLDURDDL.RUSRDRSLRL", "DLSRDSS.ULSUSSDULRSSSD.", "UDS.UUSRDRLRL.UD.....S.", "RUSDSSUSSULSRSLSDSLDSU.", "SDLRDRLSS.ULDDSUUDUS.DD", "SS..SULRURD.ULRD.SRL.SS", "RUDDRLRSDUUDSD.S.UU.DUS", "RSURSUS.USSUDL.RSSSSLDU", "RL.DDRL...RDUL.RSD..DL.", "DURLRURDDSUS.S.USL.RURD", "S.RSSDULRL.USU..DLDL.RU", "SRDDSLDD.RLDLRL.UURSL..", "RLRL..RUDLSSSSS.DLDDUSD", ".....DD.UUSRLRLDLRLRSLS", "DDDDDUU..DU.RSSLRLDD.UU", "RLUUDLDSSLDSUDSSUSULRD.", "DSL.RLRL.RLDSLDSLRSDRL.", "ULSDD..ULRDRLDLDL..UD..", ".SSSSRLRUDUDLRSL.DSSLRD", ".RLUUULUSU.RSSSSSU...UL"}

Returns: { }
{"...RSLRL........RLRDRLDSSSLDLDD.DL.DSSLDD", "RD.S.SRL.RDDSLRDUUULSULRSSLUUUL.SSDU.DLRL", "UL.RSURD.UUS.SRL....RDRLDL...DL.RUUSLUSD.", "....RSURSSSL.USL.RSL.UU.SUSSDUURSSD.RLRU.", "RL.RLRLDSSSD..RU.UDRSSL.USD.SRLRSLRSLSSDL", "SS.S.UUUD..RSSLDSSU...UDRSL.SUL..SDSLSSUL", "SS.USSDDUDSLRD.RSL..RSLSS.DLSDSSLSS.RUUSD", "SRSL.RLS.SRLSSDD.RD.USUUURURLUSDSSS.SDLRU", "UD.S.S.RSUSRUUUUL.RSSSD..USSD..SSSUDSUURD", "DU.ULSDDRSUUD.DDS.DL..USSLDDRSSURLRUS...S", "S...SRURUDDDLDLRL.ULRSSL.SUL.DL.DDSDLDD.S", "RSSSL....UURSL......USSL.RSSSLRSLULUSUUSL"}

Returns: {".../-\\/\\......../\\/\\/\\/---\\/\\/\\./\\./--\\/\\", "/\\.|.|\\/./\\/-\\/\\\\/\\/|\\//--/\\/\\/.||//.//\\/", "\\/.\\-//\\.\\/|.|\\/....\\\\///\\.../\\.\\/\\-\\\\-\\.", "..../-/\\---/.\\-\\./-\\.\\/.|\\--\\\\//--\\.\\\\//.", "/\\.///\\/---\\..//.\\\\\\--\\.\\-\\.|/\\\\-\\\\-\\||/\\", "||.|.\\/\\\\..\\--//--/...\\\\/-/.|\\/..|/-/||\\/", "||.\\--\\///-\\/\\.\\-\\../-\\||./\\|/--\\||.//\\-\\", "|\\-\\.//|.|//||/\\.\\\\.\\-/\\///\\/\\-\\|||.|/\\//", "\\\\.|.|.\\-/|//\\/\\\\.\\---\\..\\--\\..|||\\\\|\\/\\\\", "//.\\\\|/\\/-/\\\\./\\|./\\..\\--\\/\\\\--/\\///|...|", "|...|\\/\\//\\////\\/.\\//--\\.|\\/./\\./\\|///\\.|", "\\---/....\\/\\-/......\\--/.\\---/\\-/\\/\\-/\\-/" }
{".DDRSL", "SRURSU", ".RD.DD", ".SS.SS", ".SSRUS", "DLSRDS", "SRL.SS", "SSRSUS", "UUSDSL", "DSUUSD", "SRLRLS", "SSSRUS", "SRURSL", "UD.S..", ".RDRSD", "DDSRSU", "UURLRL", ".DSLRL", ".RSLRL", "DSL.UL", "USLRL.", "RD.UL.", "UL...."}

Returns: { }
{"DDRD...DL..RSSD..DSLDSL..DSL...", "UUSUL..SS.RLRDUSSU.RL.RL.S.USSL", ".DLRUDLRU.UDUU.DDRSL.RLRDS.RSSL", ".USLDURSSSDS..DLUUDU.RLRLSRLDD.", "RSSDS....RUUL.USL.S...DL.RU.RU.", "USDRLRDDSURSL.DDS.RSD.S.RLDSLDD", "DLS..SUU..SRD.UURSSLS.RLRUS.RLS", "SSRD.S..RDSUU.DSSSDSRDDL..USSSL", "SRDUDSDSLSS.DSU.RSURDUU.RDDDRL.", "S.RSLRU.DLUDRDDSLDD.RD.RLULSSUD", "S.DSD..RL.RU.RUDLULDSU.SRD.SUSL", "S.ULRSDRSSURLDSUSDLUSSLUUSDL...", "SDLRD.USSSLSRU..SRU...USSLS.RD.", "SUL.S.....ULDDDDSRSLRL.RSDSRLS.", "SRL.S.DDRSD.UUSSSS.SSSDU.ULRSU.", "SUURL.SUU.UDDLULSUSLUURSSSSL.RD", "UDRLRDRSSSSLRL.RLRSSD.DSSSSUDLS", ".RU.SSRSSL....RL.RSSL.SRSSSSL.S", "DSSDRLUL.S.RSDRSL.RSLRLRDRSDRSL", "SRLRSSDRLUSL.S..S.S.UU..RURUUSD", "ULS...SRL.DSSL.DURUDSDDSDRUDSSL", "..USSLSRDDL.RD.UDULRSURLSUDUSSL", "DSSSDSRDULDDUU.DU.UD.RLSSDL...S", "USDDLULRL.RL.RSLDSLULRLSSS.RL.S", "RDSUSSL.SDSSLRSSUDL.RSLUURSUUDS", "SUURSSD.RL.RU.RSDRD..RU....DLSS", "SDDRL.S..DLRSLUSL.S.RUDL..DLSRU", "SUU.ULS..SS..RSSD.S.SDURSSU.UL.", "RDDDRLUSSLUL.RSSLDL.SUSSD...DU.", ".ULSSDL.RD.SRLDSDSDLRSD.S.RSU..", ".RDULUL.ULDURSU.UUUUDLS.ULRSDDL", "DLUD.DDDD.RSLDD.DLRLSSUSDUDRLSS", "SRDRSLSUL.RLSRL.SULRURLDLRUSDLS", "SRLRSDUD..SUL...RSSSL.RLDURLUSU", "SRSL.SDLDLUL..RSSSD.SRD.RSURDDL", "SUSD.SUSLSDLDSLDD.RLRLRDDL.UURU", "SRSU.S...SRLRL.SUDRU.RSLSRSSSL.", "RURL.RSSSU.ULUDRDRL.RUDSL..RLRL", "DLSUL.DSSSSLRDS.SRD.UDUL.DDRU.S", "RLS.S.RDRSSL.RUDUUL.DL.RLRUDL.S", "..SDL.RUS.....DURSSDUDRDSRDULRU", ".DUSRDUDUL.DSDS.UL.S.SRLSSRSLUD", ".USURU.RSL.RSUUSSL.USL..RL..RSL"}

Returns: {"/\\/\\.../\\../--\\../-\\/-\\../-\\...", "\\/|\\\\..||.///\\\\--/.\\/.\\\\.|.\\--\\", "./////\\\\/.\\\\\\/./\\/-\\./\\\\\\|./--/", ".\\-///\\---\\|..//\\///.\\///|///\\.", "/--\\|....//\\\\.\\-\\.|...//.\\/.\\/.", "\\-\\\\//\\/-//-/./\\|.\\-\\.|./\\/-\\/\\", "/\\|..|\\/..|/\\.\\/\\--\\|.\\\\\\/|.\\/|", "||\\\\.|../\\|\\/./---\\|\\\\//..\\---/", "|\\\\\\\\|/-/||./-/./-/\\\\\\/./\\/\\/\\.", "|.\\-/\\/.//\\\\\\\\/-//\\.\\\\.//\\/||\\\\", "|./-\\..//.//.\\//\\\\//-/.|/\\.|\\-/", "|.\\\\\\-\\\\--//\\/-/|/\\\\--\\\\/|//...", "|/\\\\\\.\\---\\|\\/..|\\/...\\--/|./\\.", "|\\/.|.....\\//\\/\\|/-\\/\\./-\\|//|.", "|/\\.|./\\/-\\.\\/||||.|||//.\\/\\-/.", "|\\///.|\\/.\\\\/\\\\/|\\-/\\/\\----\\./\\", "\\\\///\\\\----/\\/.///--\\./----///|", ".\\/.||/--\\....//.\\--/.|/----/.|", "/--\\\\/\\\\.|./-\\\\-\\./-\\//\\\\/-\\/-/", "|/\\\\--\\\\\\\\-/.|..|.|.\\/..\\///\\-\\", "\\/|...|//./--/./////-\\/-\\///--/", "..\\--\\|\\\\//./\\.\\\\\\\\\\-/\\\\|\\\\\\--\\", "/---\\|\\\\\\//\\\\/.//.\\\\./\\||//...|", "\\-\\//\\\\\\\\.\\/./-//-\\\\\\\\/|||./\\.|", "/\\|\\--/.|/--\\\\--///.\\-\\\\/\\-/\\\\|", "|\\//--\\.\\/.//./-\\\\\\..//..../\\||", "|/\\\\\\.|../\\\\-\\\\-/.|.///\\..//|\\/", "|\\/.\\\\|..||..\\--\\.|.|//\\--/.\\\\.", "\\\\/\\//\\--/\\\\./--///.|\\--\\...//.", ".\\/||/\\./\\.|///-\\|/\\\\-\\.|./-/..", "./\\\\/\\/.\\///\\-/.\\/\\//\\|.\\\\\\-\\/\\", "//\\\\./\\/\\.\\-\\/\\./\\/\\||\\-\\\\\\//||", "|/\\\\-/|\\/./\\|\\/.|\\/\\/\\\\////|//|", "|\\//-\\\\\\..|\\/...\\---\\.\\/////\\-/", "|/-/.|///\\\\\\../---\\.|/\\.\\-//\\/\\", "|\\-\\.|\\-/|///-//\\.\\\\\\/\\\\/\\.\\/\\/", "|/-/.|...|\\\\\\\\.|\\\\//./-/|\\---\\.", "\\//\\.\\---/.\\\\\\\\\\\\\\/.///-/../\\\\\\", "/\\|\\\\./----\\\\\\|.|/\\.\\\\\\\\./\\\\/.|", "\\/|.|.\\\\/--/.\\///\\/.//.\\\\\\//\\.|", "..|//.//|.....///--\\\\\\/\\|/\\\\///", ".//|/\\\\\\\\\\./-\\|.\\\\.|.|\\/||\\-\\\\\\", ".\\-/\\/.\\-/.\\-/\\--/.\\-/..\\/..\\-/" }
{"RDL.RLU.RSSSLDDDDDRLDL..DSSSSD.DSL..U", "DLSRURD.S.DLRLRUSRSSLS.RUDSSSLLS.ULDD", "RLUURDS.RSLSDRDUSU.RSLDURL.DLURLRLSSS", ".RD.UUUSSL.RSDSDUDSU.RLDURLRUDL.UUSRL", ".DUDS....ULDDULRLUSLDURUSRURSURSD.RL.", ".DDRSSDRDDUSUDDSLDDSS.USSDRLDSU.S..RL", ".RURDRURLRSLSSSDDSSRLDSSLRU.USLRLRD.S", "DD.UURL.RDDSSLSUUSRDDU.RLDSSDSSULRL.S", "RLS.DSU.SSUSDRUDLSSSUSLS.RSDS.RLRSSSU", "SDSLSRRSLSDLRL.RLSLUSDRU.RRLSL.SDSDDD", ".RSUSRLDLSUU..RSLSRDSLRSSDSLRSLSUDUUS", ".DLSRU.RUSDSSSL.RULUSSLRLSRDDSUSDLRSL", "RUUSSSSSSLRLDL.R.DDDDLSRUSLSS.RLRSURD", "SDRSLR..RD.ULSRLDURLRLRLDURLRSL.UDDSS", "RLS.S.RSLUSSLSSSRD.RSDRLRSL..DLDSLUUS", ".SS.S.SURRSSLSSRDSDSDRD.R..DSURLRLRSU", "RURSLDLDDSSDLSUDRLUSLDUUDSSURLRSURUDL", "SRLRDSDLSULRLULSRSLRDRLDURSDSSUSDRSUS", "SULRUSUSLDUDD.SSSDLUU.RL.SRURLDDSRSSU", "RSSL.USSSLSSSRUSSUSSLRL..SSLRLULUSDDD", "DL.RSLDSSSDSSUSUSURSLRLRSLS.RU.DSDSSS", "SSRDDLRSLDLUURLDLSRSSSSUD.SRRL.SSSRLS", "ULULS.DSUUDRDLUL..URDSSSSDS.RLRSRULDL", "RSSDULS...SDS.DSSSSSLRDDSLSDSL.SLDSUL", "SR.UDUU.DLUSURUDRSD.SRUS..SRSURU.DL.S", "RSSSLUSSRLLRLSU.SRUDSSSLDDSSD.USSLDDS", "RSLDSL.DLDLRUUDRLUSUDRL.SSS.RSLRDDURU", "SRLUSLSUUUL.DLSRSSDRDSSDSUURU.SSUUDSD", "RL..DDRDRD..SUU.RSURUUL.USDSDDULDSL.S", "RDDDULSSRURSURSSUSRSSSSSSDSRLUD.SRLSS", "SSUURDLRSSL.USDLDDRSDDSSSLSDSLS.ULS.S", "SUSDSS.RLDDRLSSSSUDDUS.S..ULDUUSSSLRL", "RL.S.UDRLUUUUUUSUSLUSLRSSDDDUSSL.DSUS", ".RDSRLRSSSSDLSURSSSD.RLDRLSRSL.RLUSSL", "RDULSSDD.RSLRSDRSSLRDUSLUDUSLUSSLDDSU", "RLL.RLUUSSSRL.SRL.SDUDLS.RL.RSSSDLUDU", "RSSLDLRSSL.SDDS.S.UL.SUL.RUDSSSDUD.SR", "RSSLULUSSSSLRLRSU....USSSLURSSSL.RSL."}

Returns: { }
{"DSLRD......RSSL..RLRSL", "ULSRURSL.DLRDRU.RLSSDL", "RLSDLS.S.UU.SRSSU.RUS.", "RDSRLS.ULDLDLRLDSSSDUD", ".SRLRL..UURURLSRSSLS.S", ".S.SRD.DD...USURD.SS.S", ".S.S.RDRUDSD.DDULRLULS", ".S.SDLRSDS.S.ULDLUL.RL", ".SDURURLSUDUSLRUS.S...", ".SRSL.ULSDL..SRDS.SRD.", ".USDUSDDUS.RSURUUSLUU.", ".RLRL.UL.USL..UDDLDSD.", "RUUDUSD.RDDSL.DLUUUSU.", "S..RL.RDSULDUDL..RSSSL", "RL..SDSUSRLS.S.RSURLRL", ".S..SRSSURLS.RLUSDRLUD", "DLRSLRSL.RLUSSU..S.RSL", "S.S..RSL.RUDSLRSLRSU..", "S.UL.RL.DSLULSRLRSLRSD", "RSSL.RU.S.ULRL.S.RLS.S", "RLRSSSSLUD.USSLUDRSUDU", "RUSDSD.UDS....RSU...UL", ".DURSL.DLUSDDLRLDSSSDS", ".RSSSSSURDRLSSSUU..DLS", "....DD..RUS.RLSRLDSURL", ".DSSURSSSLS...SRLUL.RD", "RU..RLRD.SULDSLRSLS.DU", "USSLUUUUDU.UU.RU.SS.RL", ".RDUL...SDDRD.S.RURLRU", ".SUSLRDDLRUSUSURL..UU.", ".SRD.ULSDD.UD..SDL.RL.", ".SRU.DSURL..USSUSUSUS.", ".S.RLSDL.DL.RSL.UD..S.", ".RLSSSRU.SULUDRD.RSSU.", "RSURURSSDRDS.S.RSD..DD", "USSLRDDLUSUUDRLDDSDLUL", "..RUUUUL.DSDSRLSRUSRSL", "RSL.DDDSDS.ULS.USSU.DL", "RSL.ULUSUS...USLRLRLUL", "..S..RL.DLRDDD.ULSSS.S", "RLS.RLS.RDRUUU.RDRUSDU", "SUU.USU..SRLRL.RL..SRL", "SRSDRDDD.ULULUSSSD.USU", "SS.SRUSRSSLDD..DLS.DSL", "SUSLRSLDL.RUS.DLRL.USU", "UD..UDRLSRSSU.RSD...DD", "DLDSSUUDSSDL.RSDULRLSS", "ULSRL..SSRLS.RSLRURURU", ".SRLSDSUSDLUSSLRURLDSL", ".USSURSSUUL...RL.ULUSU"}

Returns: {"/-\\/\\....../--\\../\\/-\\", "\\\\|\\//-\\./\\\\\\//.//||//", "//|/\\|.|.\\/.|\\--/.\\/|.", "\\\\|\\/|.\\\\/\\///\\/---\\\\\\", ".|\\\\//..\\/\\///|\\--\\|.|", ".|.|\\\\./\\...\\-//\\.||.|", ".|.|.\\\\\\//-\\./\\\\///\\\\|", ".|.|/\\\\-\\|.|.\\//\\\\\\.\\/", ".|//\\//\\|\\\\\\-\\//|.|...", ".|\\-\\.\\/|//..|\\\\|.|/\\.", ".\\-\\\\-\\//|./-///\\-/\\/.", "./\\\\\\.\\/.\\-/..\\\\/\\/-\\.", "//\\\\\\-\\./\\/-\\.//\\/\\-/.", "|..\\\\.\\\\|\\/////../---\\", "\\\\..|/-/|/\\|.|./-//\\//", ".|..|\\--/\\/|.\\\\\\-\\\\/\\\\", "///-//-\\./\\\\--/..|./-/", "|.|..\\-/.\\//-\\/-\\\\-/..", "|.\\\\./\\./-\\\\\\|\\\\\\-\\/-\\", "\\--/.\\/.|.\\\\\\/.|.//|.|", "/\\/----\\\\\\.\\--\\\\\\\\-///", "\\/|/-\\.\\\\|....\\-/...\\\\", ".//\\-/.//\\-\\/\\/\\/---\\|", ".\\-----//\\//|||\\/..//|", "..../\\..\\/|.\\/|/\\/-///", "./--/\\---\\|...|\\/\\\\.\\\\", "//../\\/\\.|\\\\/-//-\\|.//", "\\--\\\\/\\///.\\/.//.||.\\\\", "./\\\\\\...|/\\/\\.|.//\\\\//", ".|\\-//\\//\\/|\\-///..\\/.", ".|/\\.\\/|/\\.\\\\..|/\\./\\.", ".|\\/./-/\\/..\\--/|\\-/|.", ".|./\\|/\\./\\./-\\.\\\\..|.", ".\\\\|||\\/.|\\\\\\\\\\\\.\\--/.", "/-/\\/\\--\\\\\\|.|.\\-\\../\\", "\\--\\/\\/\\\\-/\\\\\\\\/\\|/\\\\/", "..//\\/\\/./-\\|//|\\/|\\-\\", "/-/./\\/-\\|.\\/|.\\--/.//", "\\-\\.\\/\\-/|...\\-\\/\\/\\\\\\", "..|../\\.///\\/\\.\\/|||.|", "/\\|.//|.\\\\\\/\\/./\\\\/|//", "|\\/.\\-/..|/\\/\\.\\/..|\\\\", "|/-\\/\\/\\.\\/\\/\\---\\.\\-/", "||.|\\/|\\--\\/\\../\\|./-\\", "|\\-//-//\\.\\/|.//\\/.\\-/", "\\\\..\\\\//|/--/.\\-\\.../\\", "///--/\\\\||/\\./-\\\\\\/\\||", "\\\\|/\\..||\\/|.\\-///\\/\\/", ".|\\/|/-/|/\\\\--\\///\\/-\\", ".\\--/\\--/\\/...\\/.\\/\\-/" }
{"DSSSSSD...DLRSSDRSSL..DSSSL.RSL.", "SDSL..RSL.SSRD.SUSLRSSUDSSL.UDS.", "SS.RSD..S.SS.RLUSLSRDRSU.....SRL", "UURSDRSDRSLUDDLDLRLULUSSSSSD.S.S", "RDRLSDLUSL.DURLSRD.DSD.RL..SDLRU", "SS.SSSS.RU.S..SRSL.RSL.UL.RLSDS.", "SRLUUUU.S..RD.S.DSSSDDSLDSURU.S.", "USU..DL.S.RLS.RLRDDLSRSUUDRUDDRD", "RLDSDUURL.SSUSLSRUSSUSD.RLRDUUDU", "SRU.RSSL..RL..SUL.RLDLRDSRDRSDRL", "UDRD.RSSLRSSL.RSLDL.SS.SRLS.RL.S", ".SSS.S..UL..RSLDUSRLUL.RL.RDSRSU", ".SRL.USSSSLRD.SRLUSLDSL.RD.SUUDD", ".SRSSSLDL.RLUSL.SDL.RSURDRLSDLUU", ".SS...RLRSD.....SUURSL.RLRUSSSDD", "RUUSSSDRDDURSL..SDLS.USL.RSLSSUL", "RSDDL.SSSULS.USSLULS.RDRDRSSUS..", "..SSUDULULSSRDRSLRDRDUU.SRSD.RL.", "RDSS.USD.RLSRLRSUSS.RL..UD.RD.S.", "SSSS.DLRDRDRSSSSSURSLUD..RSSURU.", "RUSRSURSUUU.RSL.....UDRL.....SDL", "DDRD....RSD.UDS.RSSSLRSLDSSLDUSS", "RU.USSD.ULUSSLS.UL..UL..UL.RLDUS", "DDRDDLUSDUSSSLUSDSRSDRSD.S...RSU", "RUULSSRSURSSLUL.RURLSRSL.SRSD.RD", "RD.RUSS..USSL.SDDDSLUURD.RU.RLRU", "SUSU.SRSLDSSDRURLUSSSLRLRDDD.SDD", "S.RL.USLSRSSLS.RSDDSSLDSLUURDULS", "S.RL...SS.RSLS.SRUS...RL...RL.RL", "USSLRSSLUSU.UU.UL.USSD.RSSDSRDRL", ".DDSSRSLRSDDDDL.RD...RSD..RUSS.S", ".SULSRLSS.SSRUUSUSRSLDLRL.RDSS.S", ".RSSU.RLUSLRSSSSSURSLUL.USLULRSU"}

Returns: { }
{".RSL.RSD..DSSL", ".S.USL.SRLUL.S", ".S.DD..RLUSUDL", "RLDUSRD....DU.", "USLRLRURLRLSRL", "DDDUDSSLRLRLUL", "RLSRURSL..DSSL", ".RUS.USL.DUDSL", ".ULUSSD..S.SRL", "DLRSD.S.DL.SRL", "UU.DU.S.SDDS..", "DD.S..USLSSUD.", "SRLS.RSD.RL.RL", "SDLRSL.S.RSDDL", "UU.RL.RU.RSLRD", "DSSUSRL..DLDSL", "SDSSLUSSDRUUSL", "SRLDSDDSL...DU", "RSUULSSDDDSLS.", "DSDRUSSRUSDUS.", "S.SUSLSRLSS.RL", "RSL.RDSUURL.DL", "DDRDULRSSL.DU.", "ULUL.DD..USU..", ".DSD.ULDD.DSD.", "RLDUDD.ULDU.RL", "SRU.RU.RSUDSDS", "SUSSDRLSRDS.RU", "RSSSUUURLRU..."}

Returns: {"./-\\./-\\../--\\", ".|.\\-/.|/\\\\\\.|", ".|./\\..\\/\\-///", "////|/\\....//.", "\\-///\\//\\/\\|/\\", "/\\///--/\\/\\/\\/", "\\/|///-\\../--\\", ".//|.\\-/.///-/", ".\\\\\\--\\..|.|/\\", "/\\\\-\\.|.//.|\\/", "\\/.//.|.|/\\|..", "/\\.|..\\-/||\\\\.", "|\\\\|./-\\.\\/.\\\\", "|//\\-/.|./-\\//", "\\/./\\.//.\\-/\\\\", "/--/|//../\\/-/", "|/--/\\--\\\\/\\-\\", "|\\\\/-\\/-/...//", "\\-/\\\\||/\\/-\\|.", "/-\\//||\\/|//|.", "|.|\\-/|/\\||.\\\\", "\\-/./\\|\\/\\/.//", "/\\/\\\\/\\--\\.//.", "\\/\\/./\\..\\-/..", "./-\\.\\//\\./-\\.", "/////\\.\\///.\\\\", "|//.\\/./-//-\\|", "|\\--\\/\\|/\\|.\\/", "\\---/\\/\\/\\/..." }
{"RLURS.R.LRLRD.DSSLRSL.", "ULRSLDDRLSUUSRS..SRDS.", "RSLDSRUUURLUUDRSDRDRLS", "SDSDSDSSSSURSU.RSDRSD.", "SUSUULSDSDDLRURDSDSLUL", "UDRLSDLUSLSDSLSSSRSLRL", "LSSSLRUSDDSSDSSSRSSLUD", "DLRLRDLDLULSURLRLRRULS", "SRLSRUDLDSDUSL..RSSDSS", "SSSSDSU.SDLRDSDSSSDSSS", "SSSLSRD.RUUULRLDLSSRLS", "SRUDSSSD....LDDULSSRSU", "SDSSLRUDDDDDLSRDLDUSRL", "SSDRLDSLSSDLSRLSDLRULS", "UL.SSSUSUUSDURUSRSSDLS", ".SDRUULRSSURSUSSDSDRDS", "SDDS..RLS.DDL.DLUSURLS", "DRURSSLRSSLRD.RSDDDRLS", "RL.SRLSRLUDDUDRDUUUDUU", "SSDURLSUURLS.ULSDSLS.D", "RLUSSSLDLSSS.RSLRSLRD.", "DSSSL.LSSUSL.RLDDRSSU.", "S.DLUSSUSDDSDSLUURDRSL", "USLRSSSSLUUURSSSSSUUSL"}

Returns: { }
{"RSSL.DSL....RD.DLRSD...RDDSSSD.RL", "S.RL.RDRSSSLRURUUUDU.RLRLUSSDRDRL", "UDS.RSL..DDUSSU..DUDDUU...RDSRU..", ".SS.RSSSDUL..DSSSL.UU..RSSUUUUSL.", "RUUSDDSSU.DSSURLDD.RDRDUDDSL...S.", "S.RSURL...S.RLSULULRUSUDSRDRSSDS.", "S.S.RLUSL.RSURUDD.SRSL.UU.USDRURD", "RSUDLSRLRSSSSL.SSRLSRL......SS.DL", "...RSURU.....USLUL.RUUSSSSSSUUSL."}

Returns: {"/--\\./-\\..../\\./\\/-\\.../\\/---\\./\\", "|.//.\\\\\\---\\\\///\\///./\\\\/\\--\\\\\\\\/", "\\\\|./-/../\\\\--/..///\\\\/.../\\|//..", ".||.\\---\\\\/../---/.\\/../--/\\/\\-\\.", "//\\-\\/--/./--//\\/\\./\\/\\\\\\/-\\...|.", "|./-/\\\\...|./\\|\\/\\\\\\/|\\\\|\\\\\\--\\|.", "|.|./\\\\-\\.\\-/\\//\\.|/-/.\\/.\\-\\//\\\\", "\\-///|/\\\\----\\.||//|/\\......||.//", "...\\-/\\/.....\\-/\\/.\\/\\------/\\-/." }
{"DLSLDRL", "UL.RLUU", "RD.SSDD", "SUSLSRU", "RSSDUSD", "DDRU..S", "SSUD.RL", "SSSRLSS", "RL.DUUL", "LRSURSL", "RSDLRLS", ".SUUUUL", ".USLRSS", ".USRSLS", "DL..RUS", "SUDLRDS", "RLUSLRL", "DURDUL.", "UDULSS.", "RLDLRL.", "S.UUSRD", "UL.DSRL", "SRDSULU", "L.USLS.", ".DLRSSS", "LSUSURD", ".RSD.SS", "DLDRLRL", "RLRSURD", "RSUSRLS", "USLRSRL", "DDSRUSS", "RLSSLDL", "RLSSRLS", "RLRLS.S", "DSD.RSU", "SRSDDRL", "RLUUSRL", "DSDLS..", "RLUUUSL", "SDLRSDS", "RUUU.RU"}

Returns: { }
{"RDDSLDLDDDSL.DD.DSSL..RSLDDRSSSSDDDRLRL...RSSD..", "UUUSLRURUS.ULUL.RD.SDSURUSSS.RL.ULRLSSS.DSUDSURD", "DDDD.DD..RD.RD.DSL.RL.RL.ULRLULRD...SSULSRSURSUS", "RLUL.RLDSSLRDRSL.RD...RDRSL.SRDSUDDLSRSLSSDSLDLS", "RSSLDSSL...SUSSSLSRSSSSUUSUDLRURSLULS.DDSSUSDUUS", "S..SSDL.RSLUDRSSLSRSLDLRLDSLRSSL....SRUUUS..RSSL", "USDSSULRU.S.SRSSLSS.ULUUSS..USDSRL..SRLDDRLDSSL.", ".RLSRL.RSLUDRSDRLSRD.RSLRU.RSDSRURSLS.SULRUS..S.", ".RSU.UDRLS.RSSUS.S.S.S.SRSDUSUS....UU.UDRU.USSL.", "...DSLSRLSDLDLDL.UDS.S.UL.SDD.SDLRSDRL.SRLRSD...", "DL.USLRL.SSSRLRDDLSS.SDDDLSUU.SUURSLUL.S.SRLULRL", "RU...DDUSURU.RSLULSS.UUSRUUDRDSRSSD.DL.S.RSURUSS", "DDDD.RURDRD..UL...SRSD.SDSSLRUSUSSU.UL.SRLRDUSLS", "ULRL.DDULSULRDRD..S..RDSULRSL.RLDDRSSDDUSSRU.RSU", "...RDRLDSUDURL.USSURSLRU.SUSLDDSRLSDLUU.RU.RDRSL", "DSDUUDLS.DLRDDD.DSDULS.RSU.RLSSSDSLSSDDDDDDUU.DL", "RSL.DUSRSURLSRU.S.RDSS.USSDSSRLSUD.RLUURUSUL.RU.", "....RLRSSLULUD..USDSULRL..SSS..RSUDSLRL..S.S.RD.", "DSSSLUL..ULUSURD.RLS.RLRDRLSRSSSSDS.RLUSLS.SRDUL", "S..DLRL.RDSRLRLSDLRL.UL.SULS..DSLRL..RSSUSRLUU.S", "SDLRSU..SULSSRLUUDL.DDRLSRLRL.S.SRSSSL...RUDD.RL", "ULRSSSL.S..SS.SRDSRSLULUUUL.RSLDURSSSSL.DL.SRSL.", "RL....RLUSSUS.UUSSSRSDSRD.UDRLRUDD..DDUDSSDLRL..", "UL.DSSLUDRSSL.RSLSSRSLSSUSDSSSS.ULRLUU.SUUS.SSDL", "RSLRSDRDSSDLDDS.RLUD.RLUSDRLRUSDSLSUSD.RSSLDLSRL", "S.SRDSRLRUSULSRDSDLUSUDSSUDSSSUS.SRSSL.DSL.USL..", "UDSSSSUSSLRD.S.UURLRSSURL.USSLRUDU.RLRLS.RSSD.RD", "RUSRURSSDS.ULRSLRSLSDD.RL....ULDLRLSSULRSLRLS.UU", "USURSSSSUUL.SDDSUSLSUU....RDRL.RDRUUL.DD.SRUS...", "DSSLDLRSSDSRLSUL.DDSDLRDDLUURL.RU..RL.UUDUDDSRL.", "S.DLUUS.DUSRDSDSLRLSSSULUU...DSLDSSLSRL.USLRURU.", "RLSUSSURLDL.ULRSLDSLULDSSD.DLSRDS...SRL.RDDDRLDD", ".UL....USL.......USSSSL..USUULULRSSSU...RLRUULUL"}

Returns: {"/\\/-\\/\\/\\/-\\./\\./--\\../-\\/\\/----\\/\\/\\/\\.../--\\..", "\\/\\-/\\/\\/|.\\\\\\/.\\\\.|/-///|||./\\.\\/\\/|||./-//-//\\", "/\\/\\./\\..\\\\.\\\\./-/.\\/.//.\\/\\\\\\//\\...||\\\\|/-//-/|", "\\/\\/.\\//--//\\\\-/./\\...\\\\/-\\.|/\\|\\\\/\\|\\-/||/-//\\|", "/--\\/--/...|\\---\\|\\----/\\-///\\/\\-/\\/|./\\||\\-\\\\/|", "|..||/\\./-\\\\\\/--/|/-\\/\\/\\/-//--\\....|//\\/|..\\--/", "\\-\\||\\///.|.|\\--\\||.\\/\\/||..\\-\\|/\\..|\\\\/\\\\\\/--\\.", ".//|\\\\.\\-\\\\\\\\-\\//|\\\\./-\\\\/./-\\|\\/\\-\\|.|\\///|..|.", ".\\-/.\\\\/\\|.\\--/|.|.|.|.|/-\\\\-/|....\\/.\\\\//.\\--/.", ".../-\\|\\/|/\\/\\//.\\\\|.|.\\/.|/\\.|/\\/-\\/\\.|\\\\/-\\...", "/\\.\\-/\\\\.|||\\/\\\\/\\||.|/\\/\\|\\/.|\\/\\-/\\/.|.|\\\\\\\\/\\", "\\/.../\\\\-/\\/./-/\\/||.\\/|\\/\\\\/\\|/--\\./\\.|.\\-///||", "/\\/\\.\\//\\/\\..\\\\...|\\-\\.|/--/\\/|\\--/.\\/.|/\\/\\\\-/|", "\\/\\/./\\\\/|\\\\/\\\\\\..|..\\\\|\\\\/-\\.\\\\/\\/--\\//||\\/./-/", ".../\\\\//-///\\/.\\--//-\\\\/.|\\-//\\|\\/|/\\\\/.\\/./\\\\-\\", "/-\\\\//\\|.///\\/\\./-\\\\\\|./-/./\\|||/-/||/\\/\\/\\\\/.//", "\\-/.//|\\-///|\\/.|.\\\\||.\\--\\||\\/|\\\\.\\/\\/\\/|\\\\.//.", "....\\\\\\--\\\\\\\\\\..\\-\\|\\//\\..|||..\\-//-\\/\\..|.|.\\\\.", "/---\\\\\\..\\\\\\-//\\.//|.//\\\\//|\\----\\|.\\/\\-\\|.|/\\\\\\", "|..////./\\|/\\//|////.\\\\.|\\\\|../-\\\\/../--/|//\\/.|", "|/\\\\-/..|\\/||\\\\\\///./\\\\\\|//\\\\.|.|/---/...\\//\\.//", "\\/\\---\\.|..||.|/\\|/-/\\\\\\/\\\\.\\-///\\----\\./\\.|\\-/.", "/\\....\\\\\\--/|.\\/|||/-\\|/\\.\\\\/\\///\\../\\\\\\||///\\..", "\\/./--\\\\\\/--/./-/||\\-/||\\-\\||||.\\//\\\\/.|\\/|.||/\\", "/-\\\\-\\\\\\||/\\/\\|.//\\\\.//\\-\\\\/\\/|/-\\|\\-\\.\\--///|\\/", "|.|/\\|//\\/|\\/|\\\\|/\\\\-//--//---/|.|\\--/./-\\.\\-/..", "\\\\||||\\--\\\\\\.|.\\/\\//--//\\.\\--\\////./\\/\\|.\\--\\./\\", "//|\\/\\--\\|.\\\\\\-\\/-\\|/\\.\\/....\\////\\||\\/\\-\\/\\|.\\/", "\\-//----/\\\\.|/\\|\\-/|\\/..../\\/\\.\\\\\\/\\/./\\.|\\/|...", "/--//\\/--\\|//|\\/./\\|/\\/\\/\\\\/\\/.//../\\.\\////\\|/\\.", "|./\\\\/|.//|\\\\|/-\\\\/|||\\/\\/.../-//--/|/\\.\\-/\\/\\/.", "\\\\|\\--/////.\\/\\-//-/\\//--\\./\\|/\\|...|\\/./\\/\\/\\/\\", ".\\/....\\-/.......\\----/..\\-/\\/\\/\\---/...\\/\\/\\/\\/" }
{"SDD..DSD.RSSSLDLRLLDD", ".SS.DUDRSL.RSLRUSSDUS", "RRUSRDDSLD.RSLRSLSRSU", "DDRL.SUSU.RLRRLR.UDRL", "UURLRSU...UUDDSLRDSRU", "LRD.RSDSSSSSDRLSUUS.S", ".SUSSLRSSDDRUDLRD.SDL", ".SRDRSSDDLRUDUSDSDUSS", "UULSUSDUL.SDLRSSUS.UU", "RDRUL.S...SSSRDLSSRSD", "RUUSLDUDSDSSRDU.RURSL", ".DSLRU.USLSSUS.RUDLDD", ".DL.LRDDSSLUSLRLSULRL", "DSSDLRUS.RSL.RURSDDSL", "SRLRL.SUSU.USULRSLRSU"}

Returns: { }
{"RD.DL.RSSL..", "SSDURLRSSLRL", "RLUSSU..DLUL", "DSSSSDRSLUSL", "S..RSLUDDSSL", "SRSU.DLUURL.", "SS.DDRL..RU.", "SRLULDLRSSD.", "RLSDLSSRSSU.", ".SSULRURSDDD", "DUUSLRDRSLRU", "S..RLRLRLDSL", "UL.RSSDUUULS", ".RSSSSLDSDRU", "DSSDDSLS.USD", "RSSURDSRD.RU", "RLRLRUUSU.S.", "RLRUUSSSSLRL", "....RL...RLS", ".DL.UU.DD.UL", "DLUSLDDUL...", "USSDSRURDDL.", "DSSUS..ULSS.", "RSSDRSSL.SS.", "DSDRD..RDRL.", "RDS.RL..UL..", ".UL.DU...SDD", "DSD.UD.DDRLS", "USL..RLSRDRL", "RSSSSLSRSLS.", "USL..SUDRDUD", "DLRSSL.UURSL", "SSRSSDRSL...", "RUS..SS.RLRL", "DLUSSURSLSSS", "SS..RSSSURLS", "SSRDUSD..DSU", "SRLSDLUD.SRD", "S..SRLRU.SRU", "SDSUDLRSDSDL", "UUDSUULRLUUS", "DDS..RLUSL.S", "SSSRLUL..RLS", "UURLSRL.DDSS", "RSSDSUL.UUSS", "USSURSU...UL"}

Returns: {"/\\./\\./--\\..", "||//\\\\\\--//\\", "\\/\\--/../\\\\/", "/----\\/-/\\-\\", "|../-/\\\\/--/", "|/-/./\\\\//\\.", "||./\\\\/..\\/.", "|\\\\\\//\\/--\\.", "\\\\|/\\||\\--/.", ".||\\/\\//-\\/\\", "//\\-\\/\\\\-/\\/", "|..//\\//\\/-\\", "\\\\.\\--\\\\/\\\\|", ".\\----//-\\\\/", "/--\\/-\\|.\\-\\", "\\--/\\\\|\\\\.//", "/\\/\\//\\-/.|.", "\\/\\/\\----\\\\\\", "..../\\...\\\\|", "./\\.\\/./\\.\\/", "//\\-\\/\\\\/...", "\\--\\|\\//\\/\\.", "/--/|..\\/||.", "\\--\\\\--\\.||.", "/-\\\\\\..\\\\\\/.", "\\\\|.\\\\..\\\\..", ".\\/.//...|/\\", "/-\\.\\\\./\\\\/|", "\\-/..\\\\|\\\\//", "/----\\|\\-/|.", "\\-\\..|\\\\/\\\\\\", "/\\\\--/.\\/\\-/", "||/--\\/-\\...", "\\/|..||.\\\\/\\", "/\\\\--/\\-\\|||", "||../---/\\/|", "||/\\\\-\\../-/", "|\\/|/\\\\\\.|/\\", "|..|\\///.|\\/", "|/-//\\\\-\\|/\\", "\\//-/\\\\//\\/|", "/\\|..//\\-\\.|", "|||/\\\\\\..\\\\|", "\\/\\/|//./\\||", "/--\\|\\\\.\\/||", "\\--/\\-/...\\/" }
{"SDLRRDDSSSSLDSSDRD.SDDLS.RLRSL", ".SRSLSSDLRLSSLRLSUSSDSS.DLSRSL", ".SRSSLSSSSSSUSU.RD..SSUDRSUDL.", "RUS.RLRUSUUSDSD..UDDLUDRLDSLUD", "RSULSRSLSDLRUSUDRLSUSSL.UUSDDS", "..RDRLDUULUD.DDSSUUDDD...S.ULS", "DSUULSSDD..RSUSRLRLRSSRLLRLDSL", "S.SDSSSSSRLDSLSDDLRSLULS.RUSRL", "UDURUSSULSSRSUUSL.DL..DUS.DLSS", "DL.S.SUSSUUSSD.DDRUUL.SSRSUDUS", "USSLRUDLDDRSLRLRLSDDS.USLRLUSL", "RD.DL.RURUS.SDS.RLSDL.RDURURSL", "ULUUSL.DDUSDSDL.S..USSLSRSDUDS", "DLSDRU.UUUS.ULRRLRLD.S.RLDL.UU", "DSSSLRSLDDSU..DU.RU.DSSDSRSSDR", "RSDDUULSSUUDSLUDS...SDDSRLUDL.", "D.USLRUSSL.S.S.SDSLRUULSRURUDS", "RSSLUUSUL.RU.RSURSUSRSDS.DLRSL", "RLRURDRL.LRSSSSSSDSRU.UU.RLS.S", ".SS.ULSSRDDSSSLLRRSSSSSL..RU.S", "RURLDSLUURUURLUSSLS.RDRL.DDDDS", "SDSURSSSLDSLULDSDUDUSUURLULSUU", "RLDDDD.RLUSL..USLRURU.DLSDDSRL", "DLSSSRDUDDSDRSLRLS.SDDSRUSRLRU", "ULRLRSLSUL.RUURLUULRURLRSL..U."}

Returns: { }
{"DL...RSSSSLRDDLRSSLDLRLRSSL..RDDL", "SRSSDS....UURLSS.DLRLUURSDSDLRUUL", "RSL.SRSLDSSD..RLDLRD.....SRUSDDDD", "DDS.S..UURLRDRSDSRLRSLRSSLDSURURL", "RUS.SDSSLRLRURDSULDSSUULDSU.RL.DD", "..USUSDDRSLSDSUUSLUSSSLSS...SS.UU", ".RSSSUSS.DLSRLDSSURSD.SSUSL.SUD..", ".USD.RURSL.ULUUDL.ULUSUS.DU.RDRSL", "DSDRDRL.DLDSL..SRD.SDSDUSLDLDLRLS", "RSU.SDL.SRUDL.RL.RLSS.ULRSLRU.SSS", "RDRSUSRLSDDRUDLRD.ULRLDUUSSDDLSSS", "RLS..RUSRUUD.S.UL..RSUULRSDSULSSS", "DDRSSL.RSDDLRLRSLDDRSSLSUSLSDDULS", "UL...USSDSS.USU.UURLRLSRL..SRU..S", "DL.RSL.DLRLDSDDSL..SSSRLRSLUD..DU", "SRSU.RSL.DSL.SRSU.DUSRDRSDRSU.DL.", "S.DDDDRL.S...SRLRLS.UDRL.RDDDRU..", "RSUSSSSS.RSLDUUUSRU..RLUL.SUUSDD.", "DD.RLSRLDSDSUSSLSDDDSLUSUDL.DURU.", "SRSLRU..RSLUDDLRLSSRLSDL.S.RU.DL.", "RSSLRSSSSSSSLRL..RU.ULUL.RSL..RL."}

Returns: {"/\\.../----\\/\\/\\/--\\/\\/\\/--\\../\\/\\", "|\\--\\|....\\/\\/||.//\\/\\/\\-\\|/\\\\/\\/", "\\-\\.|\\-\\/--\\..\\////\\.....|\\/|/\\/\\", "/\\|.|..\\//\\\\\\/-\\|//\\-\\/--//-/\\/\\/", "\\/|.|/--\\\\///\\\\|\\//--/\\\\/-/./\\./\\", "..\\-/|/\\\\-\\|/-/\\-\\\\---\\||...||.\\/", "./---/||.//|\\\\/--//-\\.||\\-\\.|\\\\..", ".\\-\\.//\\-/.\\\\\\//\\.\\\\\\-/|.//.\\\\\\-\\", "/-\\\\\\\\\\./\\/-/..|\\\\.|/-\\\\-//\\///\\|", "\\-/.|//.|\\//\\.//.\\\\||.\\\\/-/\\/.|||", "/\\/-/|/\\|/\\\\////\\.\\/\\\\//\\--\\/\\|||", "\\/|..\\/|\\/\\\\.|.\\/../-/\\\\/-\\|\\/|||", "/\\\\--\\.\\-\\/////-\\/\\\\--\\|\\-/|/\\\\/|", "\\/...\\--\\||.\\-/.\\/\\\\/\\|\\\\..|\\/..|", "/\\./-\\.//\\//-\\/-\\..|||\\\\\\-\\\\\\..//", "|\\-/.\\-/./-/.|\\-/.//|\\\\\\-\\\\-/.//.", "|./\\/\\/\\.|...|/\\/\\|.\\\\\\\\.\\\\/\\//..", "\\-/|||||.\\-\\//\\/|\\/..\\\\\\\\.|\\/|/\\.", "/\\.\\/|\\//-\\|\\--\\|/\\/-\\\\-///.//\\/.", "|\\-\\//..\\-/\\\\/\\\\/||\\\\|/\\.|.//./\\.", "\\--/\\-------/\\/..\\/.\\/\\/.\\-/..\\/." }
{"RSL...RSD....RSL.DLDSSL", "S.SRDDUSLRDRDSLRLUUSS.S", "SDUUUDSLRSSUUSRSLDDRSLS", "SULRDRSLDUUD.RLRDSRSLRL", "USLSUSLDSR.RLRSUSSRDULU", "DD.RLDU.SDSSURD.SSUL.S.", "SSDLSUDDLUD.DDSDUUSSSL.", "ULSSRSUSRDSDLSRUDDRSDDD", "DLSSDD.ULSSRSURLSSRDSSS", "SSRUUURSLSUSSDSSULDLSRU", "SUSSD.RSUS.DSURL..S.S..", "S.U.UDDSSU.SRLRSD.RLRD.", "SRLDLRU.DSSURLUSU.RL.RD", "ULSRLSRSLRSSL.RDRLS.RDS", "RDUSSLUSSLS.S.UUSUL.ULS", "SS...S.RLRLRLRD.RSSSD.S", "SS.DDSRUSSUURUSDSSSDRLS", "SRLSSUU.UL..RLRLRL.S.SS", "USUSUSLRDRSSSL.RUL.S.UU", "...SDSLUUUSD.RD.DL.USL.", ".RDSSRSLDLDL.ULDLSS.DU.", ".UUULUSUUUUSSSSU.USSL.."}

Returns: { }
{"RL..RD.RSSLDLDLRSLDSSSSSSSDDSSSSSSL.DDDD.RLDDRD", "ULDDUU.S..UUSRLRDSSRL.DSDRLUL.RD..SDLSSUDRURLRU", ".RURLRDRD.RSU...SRLRUDLDLSRDUDRU.RLSDUS.RLRD...", ".RSLUURDUDS..DD.S.RLRL.SDUSRSLDL.SRURLRSDSSS.DL", "DD.USL.S.SRDDLSDLRUSS.RLS.UD..ULRUS..SRSUSSRDRL", "SRD..S.SRURLULSS.USLS.USLRDRSL.RL.RD.UUDDUURUDL", "RLS.DLRURSU.DLSULRSSLRLRDSSDLUSL.RDS...RLRSL.RL", ".SRSL.RSSLRLUDS.RL.RDRUSSUUSS....SUURSSD.UL.RD.", "DURL.RDRSUSRSUULDD.RURDSRSLUUDDDLUSLRSSUDDS.SRL", "RSURDRLS.DLDDDLSSRD..SSUSSLDDSRUSDDRSLDLSRLDLRL", "..RDUDRUDU.SSULRL.UL.RL....UUSDLSUU..UUSS..SDU.", ".RUS.RU.UD.SRDRSSL.USSDDD.DSSURUSDD.RLRLS.RURSD", ".S.RLDSSDRSL.RLRLSRD..ULSRLRDDSSUSS.RURLSRLDLDU", ".SDLRLDLRSSSLDLSSRLRD...SS.RURSD.UUDLDDUUSDUSS.", ".RLRSDUU....SRUSULRSL..DLRSDRSLUSD.UUSRD.SSDLS.", "RSDRSLRSLRD.USDUSLS.DLDUDSSUUSUDLSRSDUSU.SUURU.", "RSUS..USUSRSLDLRD.RSLULDU..RDDLSUUSDL.DSDS.DUDD", ".DSURSSL.S..RUDLS..DLRDSDSDSSRLRSSLRLRLDUSDU.SS", ".S.DLRDRDS.DLDL.UD.RLRLUURUSUD....DSLSRL.ULDDUU", ".USU.SS.UU.SSULDDUSSL.DSLULUSLDSL.S.RLRLDSLULDL", "DD...SSRD.DUS.SRU...S.ULS.UD..S.SDU.ULRUUSL..RL", "ULRL.RURL.ULSDU.DSD.RSSUSRDSRSL.RL...SRSSL..RSL", ".DLS.DSD...SSS..ULS....DUSUURSSSLDDRSLDSLRSLS.S", ".UDSRL.SRSSLSSRSLSS.DSSL.RSLDSL.SRUUD.USL..SRDS", "..RURSSLSDL.RLUSUUU.SDD.RSDSRSU.S.RDRSLDSL.RDRL", "DSLRSDDDSSS.DSSDDL..ULSRURURLRSLSDURSSUSRU.DLDD", "RDRLRUSUUSRSUDDSRLRSSSURSLRDRUDLRL.....UU..S.UL", ".SRSL.UL.S..DLSUD.S.RSSSSSUSRLRSSSLDSDDSSL.S.RL", ".SSRSD.SRLRDUSL.S.RLRD...DDSSS.RSLRL.UU..S.RDUU", ".RLS.RSLS.UUDD.DL..S.S.DSLULSS.SRLRD.DSD.S.RL..", ".RSU...DL..DLS.UDRSU.SDL.DDDLRSUUDSS.RDUSURLDSL", ".RLDSSLULRSL.S..SSRSLSRLRLSSDSLDSLUL.RLDSLSRUDL", "DLSSDSU.SSRSSLDLRLRDSUDRU.ULS.SS.RSSLUDUSLSS.RD", "RLUUS.RSLSRSL.UL...RL.S.DSSSLRLULRSSU.USD.SRSLS", "DSSLRSUDSU.DUDSSSLRSL.SRUDSSLUSSU..DSD..S.SRLRU", "SRLS.RSLDLRLRL.RSURLRDUU.SRLSRDRSSDSRU.RURLSS..", "ULSS.S.RLSSDU..RSSLUDRSSSLSULSSUSSLSUL.SDUDLSDD", ".DLRDRSU.RUS..RSL.S.RD.DSLRL.SS..DDS.S.SS.S.RLS", "RL..USSD.RLRSSLRL.SDLRSL.RSUDURL.RLS.UDRU.S.DSL", "SDL....S.SS..RSLDDSSSDSSSD.DL.DU...SDDRSSLUSU..", "RLSRDRSLRLRSDUD.SUUSSRSSSU.RL.S.RSSLSRSLDURL.DL", "DLRURL..UL..RDUSU.DURSSLRL..S.SRLRSDRSLSS.RLDUS", "UL..RDRSDS.RDSRLRDULRD.SUU..UDUL.S.S..ULUL..RSU", ".RSLRLSDUSRUULSSSS.RLSDURLRSLUD..USLRSDDSLDDDD.", ".S.SRSLSRLSRSDUUSRDDSUUDSSUSL.USLDD.USURSSURURD", ".USUSDDSS.SS.USSU.RLDDRLSRLDLDL.SRLRLDDDD..DSLS", "...DUSULUDSUDDSL.DD.RUSRU.ULSSSDL.DLRLSULDDS.UL", ".RSU.RSDDUS.SRDULUU.RSURD.RLSSSSRDSRSSLRDRUUSSL", ".RSD..RUS.SDL.RLRSL.SDD.S.RLSRUSULRURSDSSDSSSSL", "...RSSL.RSLUSSSU..USLRU.USSSL..USSSSL.RLRL....."}

Returns: {"/\\../\\./--\\/\\/\\/-\\/-------\\/------\\./\\/\\./\\/\\/\\", "\\//\\\\/.|..\\/|\\/\\\\||/\\./-\\//\\\\./\\..|//||\\\\\\/\\/\\/", ".//\\\\/\\\\\\./-/...|\\/\\/////|/\\\\\\\\/.//|//|.\\\\/\\...", ".\\-\\\\/\\\\\\\\|../\\.|./\\//.|//|\\-//\\.|//\\\\\\-\\|||./\\", "/\\.\\-\\.|.|\\\\//|////||.//|.\\\\..\\///|..|/-/||\\\\\\/", "|\\\\..|.|////\\\\||.\\-/|.\\-//\\\\-\\.//.\\\\.\\//\\\\////\\", "\\\\|.////\\-/.//|\\\\/--//\\/\\||/\\\\-/./\\|...\\//-/.\\/", ".|\\-/.\\--\\/\\\\\\|.\\/./\\\\/||\\/||....|\\//--\\.\\\\./\\.", "///\\./\\/-/|\\-/\\\\/\\.\\//\\|\\-\\\\//\\/\\\\-\\\\--//\\|.|\\\\", "\\-/\\\\\\/|.///\\/\\||\\\\..||\\--//\\|\\/|/\\\\-\\/\\|\\/////", "../\\\\\\////.||\\/\\/.\\\\.\\/....\\/|/\\|\\/..\\/||..|//.", ".//|.\\/.\\\\.|\\\\/--\\.\\--\\/\\./--/\\/|/\\./\\//|.//\\-\\", ".|.\\\\/--\\\\-/.\\//\\|/\\..\\/|///\\/--/||.\\/\\\\|///\\//", ".|/\\\\//\\\\---\\/\\||\\/\\\\...||.\\/\\-\\.\\//\\/\\\\/|//||.", ".\\/\\-\\\\/....|\\/|\\\\/-/..//\\-\\/-\\\\-\\.\\/|\\\\.||//|.", "/-\\/-//-\\/\\.\\-\\\\-/|./\\///--/\\-//\\|/-\\\\-/.|\\///.", "\\-/|..\\-/|\\-\\///\\.\\-/\\///../\\/\\|\\/|//./-\\|.///\\", "./-//--\\.|..\\///|../\\/\\|/-\\||\\/\\--/\\\\////|//.||", ".|.///\\\\\\|./\\//.\\\\.\\/\\/\\///|\\\\..../-/|//.\\//\\\\/", ".\\-/.||.\\/.||\\\\/\\\\--\\./-\\\\\\\\-//-\\.|.//\\\\/-\\\\//\\", "/\\...||/\\.//|.|\\/...|.\\\\|.\\\\..|.|//.\\\\//\\-/..\\/", "\\//\\.\\/\\/.\\\\|//./-\\.\\--/|/\\|/-/.\\/...|\\--\\../-\\", ".//|./-\\...|||..\\\\|....//|\\/\\---\\/\\/-//-\\\\-\\|.|", ".\\\\|//.|/--/||/-\\||./--/.\\-\\/-\\.|\\/\\\\.\\-/..|\\\\|", "..\\/\\--/|/\\.\\/\\-/\\/.|/\\./-\\|\\-/.|./\\\\-\\/-\\.\\\\\\/", "/-\\/-\\/\\|||./--\\/\\..\\/|////\\\\/-\\|//\\--/|//.///\\", "\\\\\\///|\\/|\\-//\\|\\//---/\\-//\\\\///\\/.....\\/..|.\\/", ".|/-/.\\\\.|..//|\\\\.|./-----/|/\\\\---\\/-\\/--\\.|./\\", ".||/-\\.|///\\\\-/.|.\\\\\\\\.../\\|||./-\\\\/.\\/..|.\\\\\\/", ".\\/|.\\-/|.\\//\\.//..|.|./-/\\/||.|///\\./-\\.|.//..", "./-/...//..//|.\\\\/-/.|//./\\//\\-/\\\\||.\\\\\\-////-\\", ".\\\\/--\\\\\\/-/.|..||/-\\|\\\\//||/-\\/-/\\/.///-\\|////", "/\\||/-/.||/--//\\\\/\\\\|\\\\\\/.\\/|.||./--\\\\\\\\-/||.\\\\", "\\/\\/|./-/|\\-\\.\\/...\\/.|./---///\\\\\\--/.\\-\\.|\\-\\|", "/--\\\\-//-/.///---\\/-\\.|///--\\\\--/../-\\..|.|/\\\\/", "|/\\|./-//\\////./-/\\\\\\\\\\/.|/\\|/\\/--\\|//.////||..", "\\/||.|.//||//..\\--\\\\\\\\---/|\\/||\\--/|\\\\.|////|/\\", ".//\\\\\\-/.\\/|../-\\.|.\\\\./-\\\\\\.||../\\|.|.||.|.\\/|", "//..\\--\\./\\\\--///.|/\\\\-/.\\-///\\\\.\\/|.\\\\\\/.|./-/", "|/\\....|.||../-//\\|||/---\\.//.//...|/\\\\--\\\\-/..", "\\/|/\\/-///\\-\\\\\\.|\\/||\\---/.\\\\.|./--/|\\-\\///\\./\\", "/\\\\/\\/..\\\\..\\\\\\-/.//\\--\\/\\..|.|///-\\\\-\\||.\\///|", "\\/../\\/-\\|./\\|/\\/\\\\\\/\\.|\\/..\\\\\\/.|.|..\\/\\\\..\\-/", "./-\\\\/|//|//\\/||||.\\/|///\\/-\\\\\\..\\-//-\\/-//\\/\\.", ".|.|/-/|//|/-\\\\/|\\\\/-/\\\\||\\-/.\\-\\/\\.\\-/\\--/\\/\\\\", ".\\-/|/\\||.||.\\--/.\\//\\//|\\\\/\\/\\.|\\//\\/\\/\\../-\\|", "...//|\\/\\\\|\\\\/-\\./\\.\\/|//.\\/|||//.//\\/|\\//\\|.\\/", "./-/.\\-\\//|.|\\\\\\\\\\/./-/\\\\./\\||||/\\|/--//\\\\/\\--\\", ".\\-\\..//|.|//.\\\\\\-\\.|/\\.|.\\/|\\/|\\/\\//-\\||/----/", "...\\--/.\\-/\\---/..\\-/\\/.\\---/..\\----/.\\/\\/....." }
{"RDDRSLDSSSSDRL...U.SDDRSL", "RUSUDUURSLRLSRSL.RSSLSUSL", "USU.ULDL.SRLRSSU.UD..S.RL", "S.RSLUU..RDRSL.RSSLRLSRLS", "RSL.S.DSDRU..S.UDRDSRLRSL", "SDD.RDRSLRSL.USDRUUUDDRD.", "SRL..SS..RSL.RSLRD..ULRU.", "S.SDSU.DLUL.DURSUSRSSSSSL", "RD.USD.RUDLSUSL.DLRL...DU", "RU.RDRSL.SDSL...RSLRSSDRD", "SRDRL..SDLSRLRLRD.UL..RSU", "SSSRSD.RURUS.SSULDSLDSSSL", "SSSSRLRD.SLRDSSRDS.RU.DDS", "SSSSS.RU.USLULSULRDRSLRLS", "SSUUSDSDRSLUDRLRL.USSUDLS", "SUSSLRLSUSU.SS.SULRDRSLRU", "UL...RUUSDRSLUDS.RURURL..", ".SDLDL.SDUS...RL....DLUSL", ".UUULRSDS.USL..DDDSDS..DS", "...RLRSUUSSDSDLRUSDLSRSDS", "DSDSRSSSSSSLSSRSDUUDSS.RU", "USURL.RSSSLSSSRDS.RDRUDSD", "DLRLS.UDDLS.SSRUSDLRSSL.S", "UUUURSSURUUSLRSSLUSSSSSSU"}

Returns: { }
{".DD.RSLRSD", ".RURU.SRLS", "DD.S..SRUS", "SUSL.DLRLS", "SRD..RSLUU", "SUL.RSSU..", "S.DSUDSSSD", "USU..SRLRU", ".RLDSUSUL.", "RURURSU.RL", "S.DSU..RUS", "S.SDSSSLRL", "S.SRSSSSL.", "UDRD....RL", ".S.RSDRLRL", "RU.DSUSRD.", "S.DL..RLRL", "USL..RLS.S", "RD.DLUURDS", "UURLS.DSUS", "..S.S.USSL", ".DUDU.RSSL", ".USU.RL..S", "DSDDSURSSL", "RDSUL.RDRL", ".RURL..SRL", "DD.USLDLDL", "UU...UL.RU"}

Returns: {"./\\./-\\/-\\", ".\\///.|\\\\|", "/\\.|..|//|", "|\\-/.//\\\\|", "|/\\..\\-\\\\/", "|\\/./--/..", "|./-//---\\", "\\-/..|/\\//", "./\\/-/|\\/.", "//\\//-/./\\", "|./-/..//|", "|.|/---///", "|.|\\----/.", "\\\\\\\\..../\\", ".|.\\-\\/\\\\/", "//./-/|\\\\.", "|.//..\\\\\\\\", "\\-/../\\|.|", "/\\./\\\\/\\\\|", "\\///|./-/|", "..|.|.\\--/", ".////./--\\", ".\\-/.//..|", "/-\\/-//--/", "\\\\|\\\\.\\\\/\\", ".\\///..|\\/", "/\\.\\-\\///\\", "\\/...\\/.\\/" }
{"RSSL.RL....DSDRSD.", "RSLS.UURSSSUDLRSU.", "DLUU...SSDDDLDSDDL", "SS.RSSSL.SSS.S.SSS", "SRLS...DSLRUDL.SSS", "UDSSDD.RSSSSLRSLUU", "RLSRLRSL.DL..SRSSD", "UDRSL.RL.SSRSLRSSU", "DU..USUDDSUL..DD..", "SRD....UURSSL.RUDD", "ULRSSSSL.DL.RSSDUU", ".RSDRD.S.SUDRSSLDL", ".SRUUU.USL.ULDL.RU", ".SULRSLDSD...ULDL.", ".SRLSDUS.S.RL..SS.", "DLRLSRSURLDURD.SS.", "S..SSDSSU.ULRU.UL.", "USSLUL.....RL....."}

Returns: { }
{"DSSSSSSSDRL", "SDLRL...SSS", "SULRUDSLSRU", "RSLRSLDUUD.", "..RU.RU..S.", "DL.DLRSSLRD", "SS.UL...SDL", "SSDLRLRDRU.", "SSRUULSS...", "SRDDD.SRSD.", "RDSRL.RD.S.", ".SUSDRDS.S.", ".USSLRLUSU."}

Returns: {"/-------\\/\\", "|/\\/\\...|||", "|\\/\\//-\\|\\/", "\\-\\/-///\\\\.", "..\\/.//..|.", "/\\./\\\\--\\\\\\", "||.\\/...|//", "||/\\/\\/\\\\/.", "||\\/\\/||...", "|\\\\/\\.|\\-\\.", "\\\\|\\/.\\\\.|.", ".|\\-\\/\\|.|.", ".\\--/\\/\\-/." }
{".RSSSD.DSDRSL....DL..DLDLDD.RSSSSD..DSSSD.", ".S.RSUDUDLULSRSLRUUSLULUUSS.UDRL.RL.UDRSU.", ".RDRSLSSSDLSSSRLUSDDUDLDDSS..RUS..RD.SS.RD", "RSLRSLS.RUUUSSS..DURDRLRUUU.RLDU.RLS.SS.SS", "S..SRDS..DLDUSRD.S..USL...RDSRL.RURL.UU.RU", "SRSURLUSSLSULS.S.RSLDDUSL.ULULRLS.DDDL....", "SUSLDL...DL.SRLS..DUSRSLS..RSLRLUDRLULDSL.", "S..RLUDRSL..RSUS..UDRSSLS.RL....RU.RDDL.S.", "S.DSD.SSDSSSD.RLDSLSRSD.RDRSD.DLUL.SRURDS.", "RLUDUSURL.DDRDSDURUSS.RDRL.RUDUUSU.RSSUSS.", ".USU......UU.ULRSL.RL..RL..RSU.........UU."}

Returns: { }
{"DSLDSLRSSLRL.RSSLDLDSDDL..RDRD.DSSL.", "ULSUDSSRDSSSDLRSLSSS.SSSDDRUUL.UL.S.", ".RU.UUSRLRURL.S.DLSUSURURL....RDRSL.", "..DSSSL.RD..DDRSU.RSLDSDDDRLRDSSDSD.", ".DU...RDUU.DURSSL.DDSRSLRUSSRUUUS.RL", ".RDRL.SRLRLUDDSLUDRLSRSL..ULRD..USSL", "RDSRL.S.SRUDUS.S.SDLSS.ULDL.SUSSSLDD", "RLUSSSL.USSU.RSL.RURURSSLUL.RSSSSURU"}

Returns: {"/-\\/-\\/--\\/\\./--\\/\\/-\\/\\../\\/\\./--\\.", "\\\\|\\\\||/\\|||///-/|||.|||/\\\\/\\/.\\\\.|.", ".\\/.\\/|\\/\\/\\/.|.//|\\-/\\/\\/..../\\\\-/.", "../---/./\\../\\\\-/.\\-\\/-\\/\\/\\/\\||/-\\.", ".//.../\\\\/.//\\--\\./\\|\\-/\\/||\\/\\/|.\\\\", ".\\\\/\\.|\\\\/\\\\\\/-\\\\\\\\/|/-\\..\\//\\..\\--/", "/\\|\\/.|.|\\///|.|.|/\\||.\\\\/\\.|\\---\\/\\", "\\/\\---/.\\--/.\\-/.\\/\\/\\--/\\/.\\----/\\/" }
{"DDULDSSSD.RSSSDUDSSSL", "SUDRUSSLSSULDDRSURD.S", "S.SRDLUSSL.SSRLRLSUSL", "SRUSSDLSSDSUSDUSSUSSL", "RL.ULRLULSLDUULSUSD.S", "DSSDDDR.LSRUDSURL.S.S", "SS.SSUSSDULDLLUSSUUDS", "RSSUSDLSSDLSDSL.SRLSS", ".SU.SUL.UURLRSLSUUSSS", "RLRLRLRRSD..RDLRSLSUU", "RUSRDUDSRURSUSDU.ULS.", "UDU.USLSUDUSSLRDDSLDD", "DLURD.DSSRSDSLDLRSLSS", "UD.UUDSLSDDSRSL..RLRL", ".USSDSDD.SSUU.RSSUUL.", "DSD.SSUU.SUSD.RSD.RL.", "RSU.SSRSDSDLSDLDUDL.S", "DSDDUSUSURD.SRUSSRDRD", "RSURSURDRLSLRSSU.DURU", "DDRSD.ULSSUSLSDSSLDDD", "RUSDUSSLSRSDSDURL.RRL", "DLSD..RUULRLRLDUURDLS", "SSRLRDSDSUSDDLDDRLUSD", "ULDULRUUSSLDUUUUUSSSU"}

Returns: { }
{"DSSD.", "S..S.", "SDSU.", "UUDSD", ".DU.S", ".RSLS", "DSSLS", "ULRDS", ".SUUS", ".S..S", "DURSU", "ULUL.", ".S.S.", "DURU.", "USL..", ".RDDL", ".ULUL", ".RSD.", ".UDS.", ".DUS.", ".SRU.", ".RU..", "..RL.", "RSURD", "SDL.S", "SSULS", "RU.UU", "..RSL", "DDRSL", "SUSL.", "S..RL", "USDRL", "..SS.", ".DURL", ".RSSL", "...RD", "DSDRL", "RLUD.", ".S.S.", ".RSU."}

Returns: {"/--\\.", "|..|.", "|/-/.", "\\//-\\", ".//.|", ".\\-\\|", "/--/|", "\\\\/\\|", ".|\\/|", ".|..|", "///-/", "\\\\\\\\.", ".|.|.", "////.", "\\-/..", "./\\/\\", ".\\/\\/", "./-\\.", ".\\\\|.", ".//|.", ".|//.", ".\\/..", "../\\.", "/-/\\\\", "|/\\.|", "||\\\\|", "\\/.\\/", "../-\\", "/\\\\-/", "|\\-\\.", "|..\\\\", "\\-\\//", "..||.", ".//\\\\", ".\\--/", ".../\\", "/-\\\\/", "\\\\\\\\.", ".|.|.", ".\\-/." }
{"RD.DSLRSSL.DSSSLDD..RL.RSDRSSLRSSDDDRD.DSD..", "UL.RSLUL.ULS.DSLULDSLUSURLUSDSRSSUUUUU.ULUSL", ".DLRSSSLDSLRDUSSDDUDSSSLSDSDSSDDRSSD..RSU..S", "DURLRLRSL.RSLRSLRU.RSDDUSUSLSSSUURLUSLSRDDLS", "ULRDSRU.RSU..SDLRL...RU.SDDRLULDSLUSDSRLSRLS", "DUSSRD..SRSD.SS.RLRSL.RSLUUS.DDSRSSLULDDS..S", "UDSUDUD.SRSU.UURDRU.S.SRD.DURLSRU.DUDLRLRSDS", ".SUSURURUDSLRSDRURSLUSLRLDL.SRL.DDSDUUSLDSUS", "DU.DSL.S.USLRSLRDDDS..DD.S..SRSLSSUL...SULDL", "SDDRSL.S..RDDD.RUULS.DLRSLDLUSDSULRL.DDSDURD", "SULDSU.SRDUUSRSSLDSUDUDD..SSRDRU.DLS.UURURSL", "SDLSRD.UUUSDS...UU..RDUUDSLSSRSSLSDLRSSSSUDL", "SSSRURLRSSLSUSSSD..DLRSSURLSS..DURUDURL..USS", "SULDL.ULDSLUD.RDRL.UL...DURLUSLRSSLUDRLRD.RL", "S..RU.DSLRSLS.SRSU.DSSD.S...RDS..DL.USDSRDRL", "RDDSL.S..RLSS.SRSD.USDS.USSDULUL.SDD.RLS.SRL", ".SRSLDLRSSLSUSUUDS.DSURSSL.S.RSU.SUU.ULS.RL.", ".S.DLS.USSSURSSSLUDUL..RSU.UDRL.RLRDRDUU..UD", ".S.RURLDSSD.RSDRSLRLUL.SDL.RURL.S.RLSSDSSSSU", "DLRLDSUS..SDSLULRU.RDRSUUU.RLUSSL.RLRUSRSLRD", "RLSSRL.USDSRLRL.USL.RSLDSSL.S.DSDRLRSSLRDSRU", ".ULRSU...UU.RSL...USSSUUSSU.USU.UL......RL.."}

Returns: { }
{".RDDSLRDDSSLDDDL.RDDSSSLDLRL.RL.DLRLDSSL", "RUSRDSRLS.RUUUUUDUSUD.RURUUUDLSRUSRUUD.S", "S.S.RL..SDU..RSSL.SDU.S.DSSDSRUS.USLRUDL", "RSLDSSSSUUSSDSRSSSLRSDRDS.RUSS.S...SUSL.", "DSLUSSSSDRSSURL...DD.S.UL.S.UL.RSSSLRSL.", "S.RSD.RLSSRSD..RDDLSRU.RL.USD...RDDDSRL.", "S.DSU.UUUUS.UD.UURSLS.DUSDL.SDSSLSUUSS..", "RDUDRDRL.DL..S..DD..S.RDSSSRUSRSLS.DLSDD", "DL.RUULUSURSLSRSLULDL..SSUUS.SSDUS.RSLRU", "RLRD..RDRLS.SSRSDDURL..UUDLRSUSUSU......", "RLRLRLSSRUSDLSRLSS..RSLRSUS..DU.RSDRSDDD", "USD.RLSSDSUSDLRLUUDL.DUSRDSRLRD.RSLSRUUU", "DSL...SRURLRL...RSLS.RDRUUURURU...DUSDSL", "UDRLRDS..UU.DSSSL..RSDUSSSL..RSSSDRSLULS", ".RUULSUSDRL.RLRL.DSLRUDLRDS.RSSSDRD.RLRU", "RD..RURSLRU..SSUSU.SSDLSUUS.SDSLSRURUUL.", "SRSSLRU.RSDDSLUL...SSS.RD.RSUS.SSSRU..S.", "SDSD.USLRSLRSD.SRD.SRLDSLDLRDRSUULS..RL.", "UU.USSSU.....RSLUL.RSSU..ULUL.....USSU.."}

Returns: {"./\\/-\\/\\/--\\/\\/\\./\\/---\\/\\/\\./\\./\\/\\/--\\", "//|\\\\|\\/|.//\\/\\///|\\\\.//\\/\\///|//|\\/\\\\.|", "|.|.\\/..|//../--/.|//.|./--\\|//|.\\-\\////", "\\-//----/\\--\\|/---/\\-\\\\\\|.//||.|...|\\-/.", "/-\\\\----\\/--/\\/.../\\.|.\\/.|.\\/.\\---//-\\.", "|.\\-\\./\\||/-\\../\\//|//./\\.\\-\\.../\\/\\|//.", "|./-/.\\/\\/|.\\\\.\\/\\-/|.//|/\\.|/--/|\\/||..", "\\\\\\\\/\\/\\.//..|../\\..|.\\\\|||//|/-\\|.//|/\\", "//.\\/\\/\\-//-\\|/-/\\\\//..||\\/|.||//|.\\-/\\/", "\\\\/\\../\\/\\|.||\\-\\//\\\\..\\//\\\\-/|\\-/......", "//\\//\\||\\/|//|/\\||..\\-\\/-/|..//./-\\/-\\/\\", "\\-\\.\\/||/-/|//\\/\\//\\.//|/\\|/\\\\\\.\\-/|//\\/", "/-/...|\\//\\\\/.../-/|.\\\\\\/\\/\\///...//|/-\\", "\\\\/\\/\\|..\\/./---/..\\-\\\\---\\..\\---\\\\-/\\\\|", ".\\/\\/|\\-\\/\\.\\\\/\\./-\\///\\/\\|./---\\\\\\./\\\\/", "/\\..///-/\\/..||\\-/.||//|\\/|.|/-\\|////\\\\.", "|\\--///./-\\/-/\\\\...|||.\\\\.\\-/|.|||//..|.", "|/-\\.\\-\\\\-/\\-\\.|/\\.|\\//-//\\/\\\\-/\\/|..//.", "\\/.\\---/.....\\-/\\/.\\--/..\\/\\/.....\\--/.." }
{"DSSLDL..DLRSDURSD....DDRD", "RD.RUULLSUU.RDRSLLDLDSULS", "DUS.DDULS.UDDS..RLUL.RSSU", "RL.DUSLUL.RLSRSLULDLRSDDD", ".UDULSRDDSURU.RURSUSUSURU", "DLS.SSUUS.RUS.USL.SRD.DSL", "SULDURSDRSUDSSL.RSLDL.S.S", "S.SRSD.SDD.RSSURL.ULDDRSU", "ULDSSUDLRU.RRSDUSSSDSS.S.", ".SSRLDUSSSSDS.SDSL.RUSRSD", "DLSSS.URSSLULDURSL...SSRL", "UDSSSDDSRDSRDSLRLDD..SUL.", ".RLRURLULUURLRSLRLRSSU..."}

Returns: { }
{".DSL..RSSSLRD..DDDD..DD...RD.DD.RSLDLDSD.DL....", ".RLS.RU.DLUUUDRUSRU.DLS.RDSULUU.USUULUDS.UURSL.", "..SS.RSLRURLDUUDUSLRL.RSLSUSL..DDDLRD.SUD..S.S.", "DLSRSLDL..RLS.RU..RL...DDRSL..RLSRLRU.UDRSSL.S.", "SUURLRLDL...S.RL.DD.DSSUUD.USSL.USSD.DLS.DL.DU.", "SRSUSDDSS.RSL..USLUSLRSDDLRLDDRDDSDS.RLUDUL.SRL", "SS.DUULUU.ULRDRSDRSSSL.SS.SSSRUSRDSS.RSSLDSSURU", "SSRLDDRSD..RUSSDLS....DUS.ULRSLUDRLRDRSDRUDSDDL", "SSS.RURLSDSSSLSS.ULRSLUSU...RDS.USSDS.RLUDUDSRL", "SRL..DDULRD.DLUL.DUUSUDLRSSDULS..DLSS.SDDUSLSRD", "SRSSDUL...RDRL..RU..DSLSUL.S.DL..ULSSRLRL.RSUSS", "SRD.S..RD..SRLRDULDSLRDUDUSL.SRD.DDUUUSL..RD.RL", "S.RLRL.ULDLRLULULRLDDSSRL.RSSURU.SRL...S.DLRSL.", "USSU.RSL.RLRL.RLULDLSSSS..SRDDLRLRDSDLRU.SS.DL.", ".......USSSLRSURSLRSURLRSSLULUURL.UURURSSLRSL.."}

Returns: {"./-\\../---\\/\\../\\/\\../\\.../\\./\\./-\\/\\/-\\./\\....", ".\\\\|.//./\\\\/\\\\//|\\/.//|./\\|\\\\\\/.\\-/\\/\\\\|.\\//-\\.", "..||.\\-\\\\//\\//\\\\\\-\\//.\\-/|\\-/../\\/\\/\\.|\\\\..|.|.", "/\\|\\-\\//..\\/|.//..\\/.../\\\\-\\..//|\\/\\/.\\\\\\--/.|.", "|\\//\\\\//\\...|.\\\\./\\./--/\\\\.\\--/.\\--\\./\\|./\\.//.", "|/-/|/\\||./-/..\\-/\\-//-\\///\\/\\/\\/-\\|.\\/\\\\\\/.|/\\", "||.//\\/\\/.\\\\/\\/-\\/---/.||.|||\\/|\\\\||./--//--/\\/", "||///\\/-\\..\\/||//|....//|.\\/\\-\\\\\\\\/\\\\\\-\\///-\\/\\", "|||.\\/\\\\|/---/||.\\\\/-\\\\-/.../\\|.\\--\\|.//\\\\\\\\|\\/", "|\\/../\\\\/\\\\./\\\\/.//\\-//\\/--\\\\/|../\\||.|/\\\\-/|/\\", "|/--\\\\/...\\\\\\/..//../-/|\\\\.|.//..\\/||//\\/./-/||", "|\\\\.|../\\..|/\\/\\\\\\/-//\\\\\\\\-/.|/\\./\\\\/\\-\\..\\\\.\\/", "|.\\\\\\\\.\\//\\\\/\\/\\\\\\//\\||//./--/\\/.|\\\\...|./\\\\-\\.", "\\--/.\\-\\.\\//\\./\\\\\\//||||..|/\\/\\/\\\\\\|/\\//.||.//.", ".......\\---/\\-/\\-/\\-/\\/\\--/\\/\\/\\/.\\/\\/\\--/\\-/.." }
{"DSSU.DD.DR", "SRSDDULLDD", ".S.RDDLDLS", "DUUDSUURSU", "UDRLSRDSSD", ".RUSRLSUDU", ".S.RLUU.S.", ".RSDSUL.RL", ".RSUSSDSLS", "DSSSUDURSS", "RL.DSLSRUL", "RULRL.DDRD", ".DSRS.UURU", ".RLDURDDLR", ".RSL.UUUU."}

Returns: { }
{"DLRLRSLDD..DSSL.....DLDSD", "SSULS.SRL.DL..S.DSSDUUUSU", "RL..RSU.RSUDSSU.USLUL..DD", ".RSL...RLDLUL.DSL.S.S.DLS", ".SRU.DSL.SRLRLRSLDU.RSLDL", "DLS..RLRDULS.USL.UDDLDDS.", "USL.RSUUU.SSRSLUSSLSSRLRL", "DSD.SRLRSLULS.RSSL.UURD.S", "SDLDURLS.S..UDRL.S...RL.S", "RL.S...S.RL.RLSS.SDSL.RLS", "RL.RSSLRSSU.ULSS.UL.S.ULS", "SRSSSSUDSDRSLSSUSDRSURSSL", "SRSDRSLUSURSLSUD.SSRDS.RD", "UL.SS.S.DSLRLS.S.UUULRLRU", "DSDUL.S.S.RUSSDURDRLRSLDL", "RDRL..RSL..DUSS.UURUUSLUU", "RURLDSL.RSSL.SSDDRDRD.SDD", "S.SDUDU.UD.DSLRUSUUULDLSS", "USUSDU...RSL.DSSL..RSU.RU", "RSDSS.RDDL..RURDRSLS.RSL.", "S.SSS.SRUS.DLDLSULRU.S.UD", "UDRLUSLRDRDRSURU.RSD.UD.S", ".RSSSSSURSU...RSSSSU..RSL"}

Returns: {"/\\/\\/-\\/\\../--\\...../\\/-\\", "||\\/|.|\\/.//..|./--\\\\/\\-/", "\\/..\\-/./-//--/.\\-\\\\\\../\\", "./-\\...///\\\\\\./-\\.|.|.//|", ".|//./-/.|\\\\\\\\\\-///.\\-///", "//|..\\\\/\\\\\\|.\\-\\.\\\\/\\/\\|.", "\\-/./-/\\/.||/-\\\\--/||\\/\\\\", "/-\\.|/\\/-\\\\/|.\\--\\.\\//\\.|", "|////\\/|.|..\\\\/\\.|...\\/.|", "\\/.|...|.\\\\.//||.|/-\\./\\|", "/\\.\\--\\\\--/.\\\\||.\\/.|.\\/|", "|\\----//-\\/-\\||\\-\\/-//--/", "|/-\\/-\\\\-/\\-/|\\\\.||/\\|./\\", "\\/.||.|./-\\/\\|.|.\\/\\/\\\\\\/", "/-\\\\/.|.|.\\/||///\\/\\/-//\\", "\\\\\\\\..\\-/..//||.\\/\\/\\-\\\\/", "/////-\\./--/.||/\\/\\/\\.|/\\", "|.|////.\\\\./-/\\/|\\/\\///||", "\\-/|//...\\-/./--/../-/.\\/", "/-\\||./\\/\\..///\\/-\\|./-\\.", "|.|||.|\\/|.////|\\\\\\/.|.\\\\", "\\\\\\/\\-//\\\\\\\\-///.\\-\\.\\\\.|", ".\\-----/\\-/...\\----/..\\-/" }
{"DSSSL.", "ULRDS.", ".SUUUL", ".RSSLS", ".DL.SS", ".SRDRU", "RL.SRL", "SDDSUL", "UURU..", "...DLU", "RSLSUD", "SRLUSU", "SS..DD", "SS.DLS", "SRDRSU", "RSU.DL", "RLDDRL", "SSSUD.", "SSRSU.", "RU.RSL", "DSSL.S", "SRSLDU", "SUSUS.", "RSSSU.", "RSSL..", "SRLUD.", "SULDU.", "USSLRD", ".RSDUU", ".USU..", "DDDSL.", "SRU.UL", "UDDD.S", "DURLDL", "RDDDRD", ".SRU.S", ".SRDDL", ".SRLS.", ".S..S.", ".S.RL.", ".USUDD", "....RL"}

Returns: { }
{"..RSDRSDDL.RLDSSSL..RSLRDRSL...", "DDUSLS.SUL.RLRL..RSDUSUULS.USSL", "SS.RDS.S.DSD..SDDDDRSSSSSLDDDSU", "SUDSSUSU.S.SRSLRLSSDSSL...RUUL.", "RDRLRLDDDLRUUL...ULS..UDRDDSLS.", ".S...SUUS.UL.RSSSSLSRSDSULS.SS.", "DLDLRLDLS..SDSDRL.SUURLS..RSUS.", "UDRURLSSSDDUU.RLUSL..RSU.DSSSU.", "RL.DSUUURLUL.RSSSSD.RSD.RLRSLRL", "ULDURSSSLDSL.RL...S.RDS.ULUSUSS", ".SRLRLRDSUD...USSSUDDSRL.SDSLUL", ".RSU.RLSUDUSSSSL.DLUUS.RSUUDRL.", "DL..RSSU.SDD.DDS.SS..SDSLDLUDUD", "RUDDS...DUSRDSRL.SRDRUSDLSUDRLS", "..SRL.DDUSURLUL..RLSUDSRDULRLUL", "RDS.DSUULDDSDDRSL.UL.SULS.S.S..", "RLSRL...SSRLSSRLUSDDDRLUU.S.RSD", "..SRL.RLULDLSRUSRSURU.RD.RUDD.S", "DSU.S.SS..RLRSLSRSLDLRSURU.RLRU", "UD.RUDURSSSSL.SUL.SRLUSSLDD..RD", "DURL.ULDSSL.USLDLRLRSL..RUUSL.S", "S.RD..SRSLUDRDDU.RDRLSRLS.RLUSU", "S.RU..SRDSRLRUUSL.S.RUULUSUS.RD", "S.RSDDURLUU..DSSU.USL.RSLDLS.UL", "S...SSRSL.RSSU...RSLS.USURUSDL.", "USSDRLS.RDUL...RDUSUSDLRDDDSRU.", "DSSUDSL.DL.S.RDSRL.RLUURLULS.RL", "RSSDRSSSU..RSURU.SRLRLDL.RLUDSS", "DD.S....DSLRLRSL.SS.RLSS.RLDUUL", "SUSL.RL.SRLSSRSLRLUSSDSRD..S.DL", "ULDL.SSDLSDUS...USDDSUS.RL.RLSS", ".SSS.RURSUUSUDDRSLSS..RL.RSLSRU", "DUULDD.RD..RLULRSLSULDSL...RLRD", "RL..UL.UL.DUSRSSSLRDSRLDDDSSDUL", ".SDSSLDDRDUSLS...ULSRSLUURSSLRD", "DLS.DLSUUSDL.S.DSLUL.RSD.DSSDSS", "S.USL.S..SRL.S.RSLRSLSRL.RSSURU", "S...RSURLRD..SDSD.S.SUURD.DSSSL", "S.DSU..RL.USSUS.S.SRU..RU.SDDRU", "USU.RSSSDRLDDRLDU.SULRSL..ULRU.", "..RDSDD.SRURLUSU..USLRLRSLRLRSD", "DLSSSSSRLRD.DLDSLRDDSLUSLSSSS.S", "UURLRURL.RU.UUUSUULUSL..UUUURSL"}

Returns: {"../-\\/-\\/\\./\\/---\\../-\\/\\/-\\...", "/\\\\-/|.|\\/.\\/\\\\..\\-\\\\-/\\/|.\\--\\", "||./\\|.|./-\\..|/\\/\\\\-----//\\/-/", "|\\\\||\\-/.|.|/-/\\/||/--\\...\\/\\\\.", "\\\\\\/\\\\/\\////\\\\...\\/|..\\\\/\\/-\\|.", ".|...|\\/|.\\\\.\\----\\|/-\\|\\/|.||.", "///\\///\\|..|/-\\/\\.|\\///|..\\-/|.", "\\\\\\/\\\\|||/\\\\/.\\/\\-/..\\-/./---/.", "//./-/\\/\\/\\\\./----\\./-\\.///-\\/\\", "\\\\///---\\/-/.\\\\...|.\\\\|.\\\\\\-/||", ".|\\\\\\\\/\\|\\\\...\\---//\\|\\\\.|/-\\\\/", ".\\-/.\\/|\\\\\\----\\./\\\\/|.\\-/\\\\\\\\.", "/\\../--/.|/\\./\\|.||..|/-\\/\\\\\\\\\\", "\\//\\|...//|\\\\|\\/.|\\\\//|//|\\\\\\\\|", "..|\\/./\\\\-///\\\\..\\\\|\\\\|\\\\\\\\\\\\\\/", "/\\|./-/\\\\/\\|/\\\\-\\.\\/.|\\\\|.|.|..", "\\/|//...||\\/||/\\\\-\\/\\\\\\\\/.|.\\-\\", "..|\\\\./\\\\//\\|\\/|/-/\\/.\\\\.///\\.|", "/-/.|.||..\\/\\-\\|\\-\\/\\/-///.\\///", "\\\\.////\\----\\.|\\\\.|\\/\\--//\\..\\\\", "////.\\\\/--\\.\\-//////-\\..//\\-\\.|", "|.\\\\..|\\-\\\\\\/\\//.\\\\\\\\|/\\|./\\\\-/", "|.//..|/\\|//\\/\\-\\.|.\\/\\/\\-/|./\\", "|.\\-\\//\\/\\/../--/.\\-\\./-\\/\\|.\\/", "|...||/-\\./--/.../-\\|.\\-/\\/|/\\.", "\\--\\\\/|.\\\\\\\\.../\\\\-/|/\\/\\/\\|\\/.", "/--//-/.//.|./\\|\\\\.//\\/\\/\\/|./\\", "\\--\\\\---/..\\-/\\/.|///\\/\\./\\\\\\||", "/\\.|..../-\\/\\/-\\.||.\\/||.\\///\\/", "|\\-/./\\.|//||\\-///\\--\\|\\\\..|./\\", "\\\\/\\.||//|//|...\\-\\/-/|.\\\\.\\\\||", ".|||.\\/\\-/\\-//\\/-\\||..\\\\.\\-\\|\\/", "//\\//\\./\\../\\\\/\\-/|\\\\/-/...\\//\\", "\\\\..\\/.\\/.//|/---\\\\\\|\\\\/\\/--\\\\/", ".|/--\\/\\/\\\\-/|...\\\\|\\-/\\/\\--//\\", "//|.//|\\/|/\\.|./-\\\\/./-\\./--\\||", "|.\\-/.|..|\\/.|.\\-//-\\|//.\\--/\\/", "|.../-//\\\\\\..|/-\\.|.|\\//\\./---\\", "|./-/..\\/.\\--/|.|.|//..\\/.|/\\//", "\\-/./---\\/\\/\\////.|\\\\/-\\..\\/\\/.", "../\\|/\\.|\\/\\/\\-/..\\-/\\\\\\-\\/\\/-\\", "/\\|||||///\\./\\/-\\/\\/-\\\\-\\||||.|", "\\/\\/\\/\\/.\\/.\\/\\-/\\/\\-/..\\/\\/\\-/" }
{"SS.RSSSD.SRL.LDSLDL", ".DDSLDDULRLSDDRLSSS", ".RLSDUUSLS.RURDUURU", "RDLUUDLL.SRSSLSDLRL", "RSSRDSSRDSS.RLSRUUL", ".SSUUSULRUSSUDUDDSL", "RLUSLRL.RDRSSLRLUSU", "SRLDUDRSUSRRD.UDDSL", "UUUURDSSDRSURLRUSSS", ".RSSSLDDSRSSDSS.UDS", "UULRDDRUSSDSURL..SS", "RLRLULRSLUL.DSSLDRL", "SUSU.SSDSSSSURRSRSD", "RDRSSSLUD.RRRSDUURS", "SSSDDDDSLDSLRSLRSSU", "DSRLRURLDLUULDLSRS.", "SSDLSRSUULRDSRURSL.", ".SSRDUSD.SULS.SUDLS", "DLRLRSLS.SDDUDDLRD.", "SD...DUU.SSSDUSUSL.", "RSLDL..DSUSSRDS.DSL", "RLSULRLSDLUUSRL.RLS", "SSSDSUSSULDDDLDLSRL", "RUUU.SULR.ULUURU.D."}

Returns: { }
{".RLDSSDRSSL..DL.RDRSSLRL...DD..", ".RUS.DUS..USSLSDLSS..ULUL..SRSD", "RSDRSU.UD.DLDSUUDSUL.RDRLRDSRLS", "S.ULDSSSL.SSRLRLSRDRLRUUSLRURLS", "UD.SRL.RSLSS.SSUU.USL.DL.RSD..S", ".SDL.S.S.SSS.UL...RSSSLULRLRSDS", "RUUD.SRU.SSSDD.DSDSDDRDRUDU..SS", "S.RLDUULRLSRUUDRSUSSSRLRDS.DDRU", "S.RSLRSUUSUDL.RSD.SRU.RSLSDLRL.", "USSSDRSSSSLSS.RDS.S...SRSLS..S.", "..RSU..DSSURL.RLS.S.RSLS..RDDL.", "RSL.RLDU.DD...DDS.RSLRDS.DSUUD.", "RSSSLULDLRURSDUURL.RLRUUSU..RU.", "DDRSLDDUL.DL.RDRDRLUL..DLRSSU..", "UUSRUSUD..S.RSUUL.S.DD.RURL.RSL", "DSUS.RDSRLRLS.RSSLUSUS.RSDRLS.S", "S.DLRLSSULRLS.USSLRSLS.SRL.SS.S", "S.ULUUULDLS.RLDL.DLDLUDRU..SULS", "RD.S.RD.RLRSSLUL.RLSDSLDSSDSDLS", ".S.S.SUL.RSSSD....ULS.RURSUSSDU", ".SDLDUDL.S.DLSDLDDDDRSL.S..SRL.", ".SUDSRU..USUSSULULSUDRSDUSSURL.", ".USURLRD..RSURL.DSUDUUSURSSSUS.", "RLRDDDSUSDS.RLS.S..SDD.RU..DSL.", "ULRLULUSSUUSUUU.RSSURL.USSSL..."}

Returns: {"./\\/--\\/--\\../\\./\\/--\\/\\.../\\..", ".\\/|.//|..\\--/|//||..\\/\\\\..|\\-\\", "/-\\\\-/.\\\\./\\/-/\\\\|\\\\./\\///\\|/\\|", "|.\\\\/---/.||\\\\/\\|\\\\\\\\\\/\\-/\\/\\/|", "\\\\.|\\\\./-\\||.||\\/.\\-/./\\./-\\..|", ".|//.|.|.|||.\\/.../---/\\\\\\\\\\-\\|", "//\\\\.|//.|||/\\./-\\|/\\/\\////..||", "|.////\\\\//|\\/\\\\\\-/|||\\/\\\\|./\\\\/", "|.\\-//-/\\-//\\.\\-\\.|\\/./-/|//\\\\.", "\\---\\\\----\\||./\\|.|...|/-/|..|.", "../-/../--/\\/.\\/|.|./-/|..\\\\//.", "/-/./\\//./\\.../\\|.\\-//\\|./-/\\\\.", "\\---/\\//\\\\//-\\\\/\\\\./\\\\/\\-/..//.", "/\\/-\\/\\\\/.//.\\\\/\\\\\\\\/../\\/--/..", "\\/|//|\\\\..|./-/\\/.|./\\.\\/\\\\./-\\", "/-/|.\\\\|/\\\\\\|./--\\\\-/|./-\\\\\\|.|", "|.///\\||\\///|.\\--//-\\|.|//.||.|", "|.\\\\\\/\\//\\|.\\\\/\\.////\\\\\\/..|\\\\|", "\\\\.|./\\.\\/\\--/\\/.\\\\|/-//--\\|//|", ".|.|.|\\\\./---\\....\\/|.///-/||//", ".|//////.|./\\|/\\/\\/\\\\-/.|..|\\/.", ".|\\\\|//..\\-/||\\/\\/|\\\\/-\\\\--//\\.", ".\\-/\\//\\../-/\\\\./-///\\-//---/|.", "/\\/\\/\\|\\-\\|./\\|.|..|/\\.//../-/.", "\\/\\/\\/\\--/\\-/\\/.\\--/\\/.\\---/..." }
{"DL..DDDLRLDD....RL......", "SS.RLRURUSUURSD.SRDDSSL.", "UUDLRDRL.RSSU.S.ULUL..RL", "DLS.SSSRD....RL.RURL.RLS", "SRU.UURSURDRLRSSUDLS.RLS", "S.DSSL...UUULDSSSL.S..DL", "S.SRDRD.RL.RSL.RL.RL..S.", "S.RLRSL.SRLRLDLUURURD.RD", "RL..DDRLUSL.ULRLRL.RUDSL", ".UL.ULRL...RD..SS..RDRD.", ".RU...DSSL.UL.RURL.RUDU.", "RL.RSSU.DL..DDS.RU..RL..", "S..RLRSSL.RLUUUSUDLDL.RD", "RSSDUL....UU.DSD.UURDURL", ".DDS...DL....USL....S.RL", ".RUUDDLSUSDDSD.RDDSSL.SS", "RDRLRUSSRDSSDLDUSSDLRDRU", "RLRL..RURLULRSL.UUUUUL.."}

Returns: { }
{".DLDL.RSSDDDRL.", ".SSSRLUSSUUUUU.", "DLRUDU....DDDSL", "S.DDSDDDD.RLRSL", "S.SRLSSSSRSSSSD", "S.USDULULUSSSSL", "SDD.RDDLDDDD...", "SRU.RUSSUURUDL.", "USSSL.UU...RLS.", ".DL.....RL.S.RD", ".SRLRLDSUUSLRLS", ".SRLRUS..RD.SUU", ".RUDD.UD.SSDURD", "RSLSSDSU.SRUDLS", "S.SRUUL.RLRDUSL", "USL..RU.S.UU.DD", "RLRDDL.DL....SS", "RLUUUSSL.DSD.UL", "DSSD...RLRLUSD.", "S..RSSSLS.UD.S.", "USSSL.DSUDDRLUL", "DSSSU.S.DLULS.S", "RSD.DSUDURLSS.S", ".RL.ULRLRUSSRSU", "RURL.SRLSDLUL..", "S.RL.S.SSUSDRL.", "S..RDULUURLRLS.", "UDDUS.S..SS.SS.", ".SSDU.RSLRUDUS.", ".RUS...RLDDS.UL", "RLDURL.S.UURL.S", "SULRUS.RD.DDS.S", "S..SDLDSLDURU.S", "RSDSSRL.RLDSLRL", "..ULUL..RSU.UU."}

Returns: {"./\\/\\./--\\/\\/\\.", ".|||\\\\\\--/\\/\\/.", "//\\///..../\\/-\\", "|./\\|/\\/\\.\\/\\-/", "|.|\\/||||/----\\", "|.\\-\\\\/\\/\\----/", "|/\\.\\\\/\\/\\/\\...", "|\\/.//||\\/\\//\\.", "\\---/.\\/...//|.", "./\\...../\\.|.\\\\", ".|\\\\/\\/-/\\-//\\|", ".|//\\/|../\\.|\\/", ".\\//\\.\\\\.||///\\", "/-\\||/-/.|\\///|", "|.|\\/\\\\.///\\\\-/", "\\-/..//.|.\\/./\\", "/\\/\\//.//....||", "\\/\\/\\--/./-\\.\\/", "/--\\.../\\\\\\\\-\\.", "|..\\---/|.\\\\.|.", "\\---\\./-//\\\\\\\\\\", "/---/.|.//\\\\|.|", "\\-\\./-////\\||.|", ".//.\\\\////||\\-/", "///\\.|\\\\|//\\\\..", "|.\\/.|.||\\-\\\\\\.", "|../\\\\\\\\//\\\\\\|.", "\\\\//|.|..||.||.", ".||//.\\-\\\\///|.", ".\\/|...///\\|.\\\\", "/\\///\\.|.\\/\\\\.|", "|\\///|.\\\\./\\|.|", "|..|///-///\\/.|", "\\-\\||//.///-\\//", "..\\/\\/..\\-/.\\/." }
{"RLDSSSL...DDRLDSSL....RD.RSSSLRL", "RLS...RSSLUUULSRSLRSSLRL.UDRLSRL", "RLULDSL.DU.RSSUSDLSDLS.RSDSSUU..", "SS.SULSDUDDS..DURUSRUS.S.UUUSSSD", "UL.S.SSSRLSSDDRSLRU..RDS....RSSU", "DSDUDSSSRLSSSSRLSUSSD.RLRSSDRSL.", "S.ULULSRSUULULRLRSSSURSSL..RSDS.", "USDSDDS.DD...DSSLRSSSLDLRSLRDSS.", "DDRUUUULRLRSSUDSLUSD.RUULDUSSSS.", "UL.DSDDLDLS...SRLDSL.S..DL.ULRL.", "DSLRSUS.RURD.DLRLSDDRUDDU.DSDDSL", "ULUSL.USD..RLUSL.SUUSDLRSDS.RU.S", "DL.DU...RSSDSRSU.S.DLUL.DURD..RL", "RDRL.RSL...UURD.DLDLDSSDSDSLDLS.", "RUS..RSURDDLDDS.SRL.ULDLSS.DURU.", "RLUSD...ULUURLSDLS.DDSRSLS.SDDDL", "DURSU.RD.DDDSSUS.SRURURSSU.SUURL", "USLRLDUS.ULRDDDUDRU..RLRD..SRDDL", "RSDUUUSL..RDSSUSL...RU.RURSLRURL", "USL..RSSSSLSSRL.RDDLSRLRDS...DL.", "DD.RSL....RLS.S.UUUUSRUSSSDSLRL.", "RU.ULRD.RSU.USU.RD..S..RUSUDUDDL", ".DD.RUS.SDDRDDL.UU.DURSSDUSL.SRL", "RUS.RDULSRURLUURSD.RDULRL.RL.UL.", "ULSRLSDLULRSSLDLDLDLULUL..SRSDUD", "RLSSRLRSSURSSUUSL.ULDL..RSURSLRU", "SDLSS..DDDL.DSSDDL..RSDRUDLUL.S.", "SRSLSDLSSRLDUDDULUSSLRUS.SRLUDS.", "S.RLSSSRUDDSRURSL..DLUSU.S.S.SRL", "SDLRURU..UUSRSL.USLS.RD.RU.UDRSL", "RURSSSSDDDDLDSURL.SRSLSDURSDUSD.", "RLS.RSDSUUS.USDUL.RLRDSS.ULS.DL.", "SSRSURLS..S.RDULDDDLRURUDDUL.RSD", "UU.RDRLUD.S.RU.SUUS..DD.UL..DSSU", "...SSDU.S.RSD..SDSL.RURDRLRDRSSL", "RSDRLRSDRD..RL.SRSL.UDRLRLRL...S", "S.S.RSSU.S.RDSRL.DU..SUSDRSSSDRL", "S.USL..DSL.SSRL..SDSSL..UL.RSLUD", "S.....RURSDRURSSLSUSSSSSSSSUDSSL", "RSDDL.UDUSL.DU.DLUL..RSSLRD.UDRL", ".DLUL..S..RLSRDS..USSLDDSRLDSUUL", "RU.DSL.SRLUUSULRSSD.RDUUS..RSSL.", "SDSU.S.UUULDURSSLRURLUSDSDSSL.RD", "SS.RSL.RSSUS.USSLSRLDSLRLS..RD.S", "RUDU.DSUDD.UL.RLRUULS.SRLRSL.USU", "..USSU..RL..USUUU..RU.RURSSU...."}

Returns: { }
{".RSLDSL", ".S.UL.S", "RL..RSU", "SDSLRD.", "SSRL.UL", "SSULRSL", "UU.ULRL", ".DSD.RL", ".RSU.DL", "..RL.RU", "DSLSDD.", "RSSLRU."}

Returns: {"./-\\/-\\", ".|.\\/.|", "//../-/", "|/-\\\\\\.", "||//.\\\\", "||\\\\/-/", "\\/.\\//\\", "./-\\.\\/", ".\\-/./\\", "../\\.\\/", "/-/|/\\.", "\\--/\\/." }
{"RD.RL..DLDSD", "SS.RLRDUUS.S", "SUSLDUSDDS.S", "S.RUS.SSUL.S", "SRUDUDLSDD.S", "UU.ULSRLUUDU", "RDDSLSS.DSLD", "RLRSSURSLRL.", "RLDSSSL..SUD", "RUSDSSURLS.S", "DDSRDRSLULRL", "RUS.UL.RSDS.", "..USDDDS.SRL", "RSSLSSSRSU.S", "S..RLSRD.RLS", "USDRDS.S.SUL", "RLRLSRSU.S..", "SSRDUSSD.SDL", "SSSSRDDURLSS", "SSSSSRL.RSLS", "UURURSSSSSSU"}

Returns: { }
{"DSSSSL.RSSSD.RL......RSD.", "S....S.RL..ULRU.RSL.DU.RL", "S.RSDUL.S.DSU...S.RLS.DSU", "S.S.UDS.RDRSSL.RLDLRU.RD.", "RSLRSUUSLUSSDRDRLRLDSSDS.", ".RLSRL..UD.DUDURL..SDLRL.", ".RLSSSDSLRDS.USLRSSLSSDD.", "..DURUS.S.SULRD.S...SSRL.", ".DUDSLUSU.USUSS.RSL.SS.DL", ".RLRDS.RSDDD.SRSSDRLSUSUS", "..RSLUSU.ULUSU...USLRSSSL"}

Returns: {"/----\\./---\\./\\....../-\\.", "|....|.\\\\..\\\\\\/./-\\.//.\\\\", "|./-\\\\\\.|./-/...|.\\\\|./-/", "|.|.\\\\|.\\\\\\--\\.///\\\\/.\\\\.", "\\-//-/\\-\\\\--\\\\\\\\\\\\//--\\|.", "./\\|/\\..\\\\.//////..|/\\\\/.", ".\\/|||/-\\\\\\|.\\-//--/||/\\.", "..//\\/|.|.|\\\\/\\.|...||\\/.", ".///-\\\\-/.\\-/||.\\-\\.||./\\", ".\\\\\\\\|./-\\/\\.|\\--\\\\\\|\\-/|", "..\\-/\\-/.\\/\\-/...\\-/\\---/" }
{"L..SRSLURL.RDDDRDRDRLUDDRLRLDD.", "RSD.ULS.RUDULRLSSSRLRDSSULRLRUS", "SLRSDSRSSSLSDSLRLUSD.RLRSDDLDDL", "UDDLSRSLRLRLSURDRD.USSSSDSSSSUL", "RUSRUDSLRU.RLDDSRLRDDLDDRUSSSDL", "RLRSSLSDSLDDSRLUDURUUSLSRDULRLL", "DLRLRLUSRUSS.RDSRSL.RSSUSRLLRL.", "SRUSSUDUURLUDRL.RLRDL.DSURSSSSU", "SSDLRLSUUS.US.RSUUSL.RLDSLSRUS.", "SUUDDUUDSUDLULSDSSDLDRLRDULRSUS", "S.DURSDSDSLRSUUSD.UL.DUSRSLSDDR", "RSLSDUULSDDL.DSLUSDDDURDSLSDLRD", "RLUDDRLLUURSLUDSU.SLULUUDSSS.DU", "SSRUURUDSDRSU.SRSLUSDSRSLSSULRL", "SSL.SRSLSSRLDRUDDLD.SUUDSLSRL.S", "ULDSDUDLDRDUSLSDLRSDSDSUDSLUSSU", "RSLDUDUSLRUDSDSUSU.SSRSLSRSSSSD", "RDURD.D.ULSSRLRDSSSUSRRUSSDSSDS", "RS.LRSSSSSSUUSDRSSDRRSL.RLUL.RU", "LRSSSDRSSSSDDDUSD.UDRSDDURRLL.R", "DDRL.UU..S.ULSSRLLRSSRUSSSUD.RL", "SSRLRSSSSSSSDUSLRSDSS.SDSDRDSLS", "SS.DLRLRSLDLULRLRLSSRDDLUSRL.DS", "SSDUUSSRSLSSDSRLDSULDUUSLULRDRL", "RLRL.UUSRDSRLUDRLSS.SRSLSRSLSS.", "RSLS.RSLSRUDUSLULUSDSSDSSSDSUS.", "USUSSUSUUSSSSSSD.R.SSRSLSRU.SS.", "DLSRL.LRSSLU..LSLRLSSURLS.RDUUL", "SS.UUDUS.UUSSLRLDUSRLRUUUDSSSDL", "RU.DDSDLRSSDDUSRLDLDDRSSSLSRSL.", ".DDSSULRSRSLRSUS.RDSSRSSSLUD..D", ".RLRLDSSLSD.DRDUL.SRUDSL.RSLDDU", "RSSSDSDDSUSSSURLSSS.LRSU..SSUUL", "RSD.SSSSSRDR..DRUSS.DSDRSSLRSL.", "SSSRLSUU.UURSLDLD.USL.SSRLSSSUD", ".RLUSLRSDDDRSLSUSSSLDSULSSSRDUS", ".S.RLRRDSULRSLSRDLRLRSSDULS.SRU", "DRSLRSSLUSSL.RLRU.RSLURUSSULULR"}

Returns: { }
{"RSSD.DSL...DSSSSSSLDSSSLRSSSD.", "UDRU.USLDSSUDDDSDRUSDSSLRDDDRD", ".ULDSD.DL...ULSRLS.RU.RSSLUU.S", "DSLS.RSLRDRLRSUSDU...DUDSL.RLS", "SRURDRLRUSUURSDRUDDRSUDL.S.SSS", "SSRDSSSRLS...RLDDSSUSDUSDSDUSS", "UUSSSSULSULDDS.RLRL.RLRSUUUDLS", "DSLSSRLRL.SRUSRDDSSLULRDRD.SRL", "RDRLS.RSSLUSSLUUSRSL.SDLUU.SUD", ".RU.USSSLRL.RSSDSSDL.SSDD.RU.S", "...DLRSDRSUDL..SSRLS.RLSS.USSU", "RSDUUULSRL.SRLRLUD.SDSLRLRSDDL", "RSU.DLULSUSLSSSDLS.SSRU.RUDUUU", "RSSSUUDDURD.UURUSRSUSS..S.USD.", "S...RDSULRURLRSLULRLSSDLS.RLRL", "USL.SUL.RSSLRLDL.SULSUUUL.ULDL", "RSUDLRLDLRL.DDUSLSRDS.RDRD..S.", "S.RU.RLULUUDLSDDSSUUS.SSULRDS.", "S.RSD.DSSDDU.SRUSUSDS.SSRLRLRL", "RD.DU.S.RLS..SRLSDSLSRLSRLRL.S", "DURLRDUSL.SDLULSSSRDSULS.RUUSU", "RSU.UU....ULRSSLULRUUSUUSL...."}

Returns: {"/--\\./-\\.../------\\/---\\/---\\.", "\\\\//.\\-//--//\\/-\\//|/--/\\\\/\\\\\\", ".\\//-\\.//...\\/|//|.\\/./--/\\/.|", "/-\\|.\\-//\\/\\/-/|//...///-\\./\\|", "|//\\\\/\\//|\\/\\-\\\\//\\/-///.|.|||", "||/\\|||\\\\|...///\\||\\-\\\\-\\|//||", "\\/||||\\\\|\\\\/\\|.\\/\\/.///-/\\///|", "/-/||\\\\\\/.|\\/|/\\/--\\\\\\\\\\/\\.|//", "\\\\//|.\\--\\\\--/\\/|/-/.|//\\/.|\\\\", ".\\/.\\---\\\\\\./--\\||/\\.||/\\.//.|", ".../\\/-\\\\-///..||\\/|.\\/||.\\--/", "/-\\\\/\\\\|/\\.|/\\//\\\\.|/-\\\\//-\\/\\", "\\-/./\\\\/|\\-/|||/\\|.||//.////\\/", "/---/\\\\///\\.\\/\\/|\\-/||..|.\\-\\.", "|.../\\|\\\\\\//\\/-\\\\\\/\\||/\\|./\\\\\\", "\\-\\.|\\/.\\--/\\///.|\\/|\\/\\/.\\///", "/-////\\/\\/\\./\\\\-\\|/\\|./\\/\\..|.", "|.//.\\/\\/\\///|/\\||\\/|.||\\//\\|.", "|.\\-\\./--\\//.|\\/|\\-\\|.||/\\\\/\\\\", "\\\\.//.|.//|..|/\\|/-/|//|\\//\\.|", "/////\\\\-/.|/\\\\/|||/\\|\\\\|.//\\-/", "\\-/.\\/....\\/\\--/\\/\\/\\-/\\-/...." }
{"RSSSSLRSSD.DDDL.RLDSDDDRSSL.DLDSSSDRL.D..SRD.RSL", "S.DLRLUSSU.SSRL.SSRSLSSSDDUSUSRD..SSRL.DDDUULRDS", "RSLRUDDURL.RU...SRSSLULUUUDSDL.RSSLRSUDRUUSDRSUS", ".RSS.RU.SSDSSSSSLDSLRSSSSDS.SRDRSSSSL..DSD.SDL.S", ".RLRL.R.RLRDURRSLUDRLDSSSUS.SRDRLS.LUSLSSSDURL.S", "RSUUUSSSLDSLRSL.RDS.RLDSD.S.SRL.USDRSSLRSLRSLSDL", "DRSSSLU.UURDSDSSSLUDDSLUSSRSLRS.RDSUSDSRSSSSLRUL", ".DSD.USSLRLSSUSD.RSLS...USSL.RL.RUS..ULRDDD.DSSU", "RL.S..RSLRSUSRSLDURDRSLDSSDS.SSDSDUSSLRDRLSDLRSL", "RSLULRUDLRSLSS..USUUDRUS.DLRDUURLRSL.SRRSLSRDSRU", ".RULRU.SSUDRUULRSLRDRL.USU..RDDDUL.RLRDDLUURLUL.", "RSSLRL.SUDUD.USRSUSUSSSD..DL.SSUSLRSURUSUSDSDDS.", "SDSLRURU.USURSL.DDS.DSDSRLSUDRU...RSSLDU.DLRUSRD", "SRSUUSRSSD.DLS.DLSS.SRSSULSDURS.RSSSD.SDLUSSDSRU", "UDRSSLRSDUSL.RLRSLS.UDSSDDSRD.DLSRDRL.SUURSDSSRD", ".RUDLSUSUSDL.SRSSDULRUSSRURSL.UUSSRU..RSLUDSSSRU", "DSDRLRL.RDULRURL.S.RU.SSLDLDSSSSUUSSSSDDU.UURURD", "USL.D.USLRSSU.RLUUSSSSLUSURL....U.SR..UU......RU"}

Returns: { }
{"DD...RL...DD....DSSSSSSSSSSD...RSD", "SRSSDSUSD.SUSDDLRSSSSSSSSSLSRSSL.S", "SDSDSRSSLDU..RUS..RSLRSDDSUSSRDDDS", "SRSLUD...USSLRDUD.S.UU.SRSDUUUURUS", "S....SDD.RD.SSRLSDU...DLDDUSSLDLDL", "RSSSLRLS.ULDLRSLSUSSD.S.RU.RDSRUS.", "RDRDRSDSRSSLDSDRLDL.S.SRSD.SSRSLS.", "RLUL..UUULDSU.SSRLULRLSRDS.UL..UU.", "DD.RDDD.DUUSSLSRURLRSLULRL....DSL.", "SSDLSSSRUDDDDUU..RL.RD.RL..DSDSRU.", "ULULUUUL.SSSUDRL.DLDUUDRURSL.SUU..", "DD.S.RLRSLUL.SRL.RLRL.SRSL.RLUL.RD", "RU.S.RLS..RL.S....DSUDLDDDSUSRU.SS", "DLDL...RD.RU.USSSLSDDS.UURSSURSLSS", "SSSDSDDSU...RSDDLSSSUU.RSD..RL.RUS", "RUSUSLUDRLRLSDURUSRLDL.S.USDUUDSSU", "..S.DSLRURUSSSRD.USLUL.RD.DLRSLDD.", "DDS.SDU...RURUULRLRU.DSLRSU.UDDURD", "SSUDRLDSSSU.DSSDSRURLS.S.DDDSLUL.S", "UU.RD.RLRDRSLRLSUD.UUS.S.SSUSSLULS", "DLRLS..SULRD.RLS.S..RU.S.RLRSDS.SS", "RURLRSDS..RURSSUDL..USSURL.S.SRSUS", "...RDDURL.RSLRL.SRSL.DSDRU.SDLRL.S", "RL.SSRSDS.DSSUS.RU.RSL.RSSSUUSLS.S", "SS.SRSSLS.SRLDL......DLRL.RSSD.ULS", "RU.RD.DDS.SRUS..RL.DDRLSULRLRL.RUS", "DDRLULSSRLRSSUDLSULSUL.USU.RLRDRDS", "ULRU.ULRSU....RURSURSL.......UL.RU"}

Returns: {"/\\.../\\.../\\..../----------\\.../-\\", "|\\--\\|\\-\\.|\\-\\/\\\\---------\\|/--/.|", "|/-\\|\\--///..\\/|../-\\/-\\/-/||/\\/\\|", "|\\-/\\\\...\\--\\/\\\\\\.|.\\/.|\\-\\\\/\\/\\/|", "|....|/\\./\\.||\\\\|//...///\\\\--\\/\\//", "\\---\\\\/|.\\///\\-/|\\--\\.|.\\/./\\|\\/|.", "/\\/\\\\-\\|/--//-\\///\\.|.|/-\\.||\\-\\|.", "\\/\\/..\\/\\\\/-/.||//\\\\\\\\|\\\\|.\\/..\\/.", "/\\./\\/\\.//\\--\\|\\//\\\\-/\\\\\\/..../-\\.", "||//|||///\\/\\\\/..\\/./\\.\\\\../-\\|//.", "\\/\\\\\\/\\/.|||\\\\/\\./\\//\\\\///-/.|\\/..", "/\\.|./\\/-/\\/.|\\/.\\/\\\\.|\\-/./\\\\\\./\\", "\\/.|.\\/|../\\.|..../-////\\/-/|//.||", "/\\//...\\\\.\\/.\\---\\|/\\|.\\/\\--/\\-\\||", "|||/-\\/-/.../-\\/\\|||\\/./-\\../\\.\\/|", "\\/|\\-/\\\\/\\/\\|//\\/|\\//\\.|.\\-\\\\//--/", "..|./-\\\\/\\/|||/\\.\\-\\\\/.\\\\.///-//\\.", "/\\|.|//...//\\/\\//\\//./-\\\\-/.\\\\//\\\\", "||\\\\\\//---/./--\\|\\//\\|.|./\\/-/\\\\.|", "\\/.\\\\.\\\\/\\/-//\\|\\\\.\\/|.|.||\\--\\\\\\|", "/\\/\\|..|\\/\\\\.\\/|.|..//.|.\\//-\\|.||", "\\/\\/\\-\\|..///--///..\\--//\\.|.|\\-/|", ".../\\//\\\\.\\-//\\.|/-\\./-\\\\/.|///\\.|", "/\\.||\\-\\|./--/|.\\/.\\-/.\\---/\\-/|.|", "||.|\\--/|.|/\\//....../\\/\\./--\\.\\\\|", "\\/.\\\\./\\|.|\\/|../\\./\\\\/|\\\\\\\\//.//|", "/\\/\\\\\\||\\\\\\--//\\|\\\\|\\\\.\\-/.\\//\\\\\\|", "\\/\\/.\\/\\-/....\\/\\-/\\-/.......\\/.\\/" }
{".DSSL.DDS.RLDL..", "RL..S.RL.DLRUSDD", "SRL.RD.RLSRDDLSS", "SSUSDSDLUUUUSRLS", "SUD.RLUD.RD.RU.S", "S.RLDDRU.SRSSD.S", "S..UUULRLUSL.RDS", "S..RDRLSS.RU..SS", "SDLRURUSSDLRD.RL", "SSSDDDDULULRL...", "SRLULRU.DSU.DDRL", "S..DSSSSU.DDUUSS", "UD.USL.DSSLUD.UU", ".S.RSL.USD..RLDD", ".USU.....USSSUUL"}

Returns: { }
{".....DLDD.", "RL.DSUSRL.", "SRSU..SDSD", "SDSSLRLRDS", "SSRLUUDDUU", "ULUU..UU.."}

Returns: {"...../\\/\\.", "/\\./-/|\\/.", "|\\-/..|/-\\", "|/--\\//\\\\|", "||/\\\\//\\\\/", "\\/\\/..\\/.." }
{".RLL.DD..RSSDRLRLDD.DDDSLDLRDRDRDRSSSSD", "SSRSSUSDDSUSSUUUURLDSULSSUUSRUSSRUDSSDS", ".SRSSSUSSUSSLDSSDS.RRSLUSSDLRDSSDLUSSLS", "DSRSSSSUUDRLRLDRSRSSDRSSRSLLRLRLULRSDRL", ".SRDSDSSDSULSDDDULRSLRUDLUDDLDDLDLUSUS.", "RUSRDSDSLRSSL.ULUDL.DLRSSSDSDRUUUS.SLSR", "ULUDSUULRSSLLDDDSUDLS.DUUDUSLUSSSLRRDSS", "SULSSRSLSRDSDUSSRSLSSLUD.USSLRDRLRSUSUD", "RLSSUUSRUSSSSDLSRD.SRSSUDSLDURUUUUSSL.S", "ULULRRSDRULSSUDUDUDUSLRLSDRLURSDSDDDLSS", ".D.DLS.UDRRLSDLRLDUDDURUSRLRDSLUSLSRLLS", "DLDUSUSLUSUSSSSRSDRUULDLSSUURLR.DSL.SUS", "SSSRU.UULRSLRL.DSSRDRLRLSSDRLDDRU.DSSDS", "RLSSRLRSUSSRLUDD.RLSSRRDUL.SSRLSRDRSSLS", "DSLSDDRLDURDSDURSLSSUSLUD.SSSRSUSRSSSSL", "RLDURL.SRLSSSSRSDSULD.DSL.RUUUDDRSSL.RL", "USSR...RLRLUUSSSSRDRDSU.RSURD.SSRD.RSSD", "DURDRSSLS.RSSLUDSURSUDLDURLRDLSSUUDDURS", "RSSLRDRUS.SUULRURSSSDULULSRDRURLRSSDDDS", "...RSLRSLSUSLSRSSSD.SDSLSSDLU.RLSRLSSRU", "RDURSD.RSDRLUSSSSLSDUSRURUUDDLRLSRUULRL", "SUSSSURSLSSULUDDDUSS.RULDSSURLDDSRDURUS", "S.RSSLUS.RUDULULUSUSLDDDS.RLDDUUSRUDRSL", "SRUSLSRS.RSUDDL.DDDU.DLULDUSRL.LRDSDLDD", "S...SSRU..RSLUU.SSRLLUSLDL.SDSSDLRDSSSS", "USDRLSRSSLUSSSD.SSSUSSDSRLDUSRSLDSSRLUU", "RDLUDSDLRLDLRDRLUUSUSRLSSUUUSUSD..USDRL", ".RSDUURUSSSSULSRSSLRLRDUSD.SSDDRSSSSUUU", "RL.SDSLDURURSSLDSLULULSDLUSLRURLSRSLD.S", "SUSUSRSUSUDLDDSRSLDRLULRUDSU.SSULUSL.RL", "SURDRLS.RLRURUSDLDSLRSDLDUR.LDD.RSLDDSS", "S.RUDUSURURLRSUULSDSD.S.USSSSUUDRSUUUUU", "ULD.RSUURDRUUSSSLSUSL.USSSSD.RLULRDDLD.", "SSRLDL.USUL.DSSDUUSU.DSL.RDRSLRSLULSUDS", ".SSRUSDSUSULUSSL.LDSLRDRLUULLRLRUSLRDUD", "RLULDUSRSSDRL.RSSLUDULSRUSLRDLUSSSLRURU", "ULDUS.RLRSURLRSDLSDUSURSL.RSUDLSD.DSDU.", ".ULUSRSDS..SRSLRURSD.RLDUDSSLSSRSSLUUD.", "UDSSLSLSULDUS...RD.USLSUDS.SSRUUSDRLDSD", "SSDSDRSUDLULSSRSUUSSLUUDSUSSL...RL.SRSL", ".SSSSL.DLRSLSSSRSD.RUR.RLRSSDUDSLDLRDDD", ".ULDSDSUDL.RLRUSSSSUSLDSSUDRURLRDUSRLRL", "RL..SSDLSDSL.SDSLUSSSUSRSSDUSLRSL.SUSD.", "SRL.SSUURURLSRLS.DSSDRUUD.RD.LRSDSRSLS.", "RDRSLUSL...RDRLSDLRRLS..S..SDSSSL.RSUSS", ".S..RSSURL.SSUSUSRLULUSSURSURSDR.DRDDLL", ".RSDUSSSLSRLSDSDRUS.SLDD.UDDSSURL..RUDD", "RDSSDDRLLUU.SUSLRDRSLURU..RLD.DLRD..RUU", "RURLRUSRSSSDS.DLUU.RLRLRDDLDSLRL.S.RLRD", "S.USSSLUUR.UU.UL...RLRUUUULRSUDUSLSUUUU"}

Returns: { }
{"DSLRSLRD.DL.....RSDDDRLDLRD..RL.DSDRSSSSDRSSD.", "RSLRSLULRLRLRSSSU.RUSSSRUSRSDRUDU.SUD...UURDRD", "RLRLDL.DL.DURSSDDSLDLRU..SDDS..USSLDLDSSD.RL.S", "SSRLRL.S..USDDDSRSLS..RSDSRUS.DSSL.S.SDDS.DL.S", "ULDSSD.SRDDSURLUSSSU.DL.SRD.S.USLS.USLSSS.UU.S", "RLRD.USUSULDDRSSLDLDLSDLRSUDL.RSUUSSD.SSSDD.RU", "SS.USLDDRSLULUSSURUUURLS.RDUSLS...DSUDURLUUDU.", "SSDLDUSRD.SRSL.DLDLRLRSL.UL..SUD..SDDSRDDSLUSD", "ULRLS.RLUSLRSUDLSRLSRUDDRL..RU.SRSLSSSUUSRURDS", "RSD.ULRU......USU.DLDDRLSSRLUSSUUSDULRSLSS.SUU", "SDLRDUURDDSLDL..DDUSLUSSLSUUDSSSLDLRSL.SSS.RSD", "RLDUUL.RURDSSUSSLRD.RSD..SDSL..RUSDU.S.UUULRLS", "RLUL.SRL..UUS.DSSDUSL.SDLSRSD.DLRLSRDRL..RLRUS", "UU.USURU.DLRU.SRSU....SRUUL.S.USL.RLS.S.RUDL.S", "DSLDSSSSDSSRD.ULRD.DSLS..RL.S.RSSL..S.RSU.RL.S", "RSLSRSL.RUS.SRLRLUDRSUS.DL..SRURLUL.USSD.DDDSL", "RSSUSDURSSURURLSDSUDD.ULRSSLSRLSULUDRD.S.SUUDD", "SDL.SSDL..RLRD.RUDDUU..S...RU.SUSLDUSUSU.UL.RU", "SUU.SSRLDSURLUSL.SSDDDLS.DSSD.RSSSUDL.RSLDL...", "S...ULRLS..RSDRU.UUSUUSSDURDRDRLDSSL..RSURL.DD", "S.DSSSU.SRSSDRU.DSLRSSUSULSSDLRUS...DLDSL.S.UU", "SDU.DSSSLRSSL.DDRSU..DDSRLUUSDSDUSD.SRU.SRL.RL", "UUDDUSD.RD..DDRUDLDL.RURLRD.RURU..S.SRSLSRDRLS", "..UUDDRLRUDDRUDDULRU..DSDSS.DLS.DDUSLSDLULSRSU", "DL.RUS.SRDUU..RURSSSSDRSUSRSLSULSRSL.UUDSURD..", "SRDS.RSLSUDDDRD.SDLRLS.DDS...USUS..S...S..DLRD", "SRLUSSLDL.ULSULRLRURUS.SUU.RDDDRURSL.RLSRLS.RU", "UUDSD.UL.RL.S.DLRLRD.S.SRDRLSSSUSURSDRLSSSSDL.", "..RSL....UU.RSL.RLRU.USUUUUSUUL...RSL..RUUURU."}

Returns: {"/-\\/-\\/\\./\\...../-\\/\\/\\/\\/\\../\\./-\\/----\\/--\\.", "\\-/\\-/\\///\\\\/---/.\\/|||\\/|\\-\\\\///.|\\\\...\\//\\\\\\", "/\\/\\/\\.//.//\\--\\/-\\//\\/..|/\\|..\\--////--\\.\\/.|", "||\\/\\/.|..\\-\\/\\|\\-/|../-\\|\\/|./--\\.|.|/\\|./\\.|", "\\//--\\.|/\\/-/\\/\\---/.//.|\\\\.|.\\-\\|.\\-/|||.\\/.|", "/\\\\\\.\\-/|\\//\\/--\\/\\/\\|/\\\\-///./-/\\--\\.|||/\\.//", "||.\\-\\/\\\\-\\\\/\\--/\\/\\/\\/|./\\\\-\\|.../-///\\/\\///.", "||/\\//|\\\\.|/-\\./\\/\\/\\/-/.\\/..|\\\\..|/\\|/\\/-\\\\-\\", "\\/\\/|.\\\\\\-/\\-///|\\/|\\//\\/\\..//.|/-/|||\\/|///\\|", "/-\\.\\\\//......\\-/.///\\\\/||/\\\\--/\\-\\\\/\\-\\||.|\\/", "|///\\\\//\\/-\\/\\../\\\\-/\\--/|\\//---\\///-\\.|||.\\-\\", "\\///\\\\.\\/\\\\||\\--/\\\\./-\\..|/-/..//|//.|.\\/\\\\/\\|", "/\\\\\\.|/\\..\\/|./--\\\\-/.|/\\|\\-\\.////|/\\\\\\..//\\/|", "\\/.\\-/\\/./\\//.|/-/....|\\/\\\\.|.\\-/.\\/|.|.///\\.|", "/-\\/----\\||\\\\.\\//\\./-\\|..//.|./--\\..|.\\-/.\\/.|", "\\-/|/-\\.\\/|.|/\\//\\\\\\-/|.//..|///\\\\\\.\\--\\./\\/-/", "/--/|///--///\\/|/-//\\.\\\\\\--\\|\\\\|\\\\\\\\/\\.|.|\\//\\", "|/\\.||//..///\\.\\//\\\\/..|...\\/.|\\-///|\\-/.\\\\.\\/", "|\\/.||\\\\/-///\\-\\.||/\\/\\|./--\\.\\---///./-\\//...", "|...\\///|..\\-\\//.\\/|\\/||///\\\\\\/\\/--/..\\-/\\\\./\\", "|./---/.|/--\\\\/./-\\\\--/|\\\\||//\\/|.../\\/-\\.|.\\/", "|//./---/\\--/./\\\\-/../\\|//\\/|/-\\\\-\\.|\\/.|//./\\", "\\//\\\\-\\./\\../\\\\//\\/\\.\\/\\//\\.\\///..|.|/-\\|\\\\//|", "..\\//\\\\\\\\//\\\\//\\\\/\\/../-\\||./\\|./\\\\-/|//\\\\|\\-/", "/\\.//|.|/\\\\/..\\//----\\\\-/|\\-/|\\\\|\\-\\.\\//-/\\\\..", "|\\\\|.\\-/|\\\\/\\/\\.|/\\/\\|./\\|...\\-/|..|...|..///\\", "|//\\--\\//.\\/|\\///\\/\\/|.|\\/./\\/\\///-/./\\|/\\|.\\/", "\\//-\\.\\/./\\.|.///\\/\\.|.|/\\//|||\\-//-\\\\/||||/\\.", "..\\-/....\\/.\\-/.\\/\\/.\\-/\\/\\-/\\/...\\-/..\\/\\/\\/." }
{"DL.RL..DSL....DLRSSSDSRSL.LRSSSSSL", "UL.SUSSU.ULDD.RUSUDLSRU.SDSL..RSSL", "RL.S.L..RLUURSSDRSLSRLUSSS..DDUSSL", "SS.USSSDSSDSL.DL..DUDDLDLUSLRLDSSL", "SUSDR..UUUUSSRU.DLRSUS.RSLSUSDUSSL", "UDLSRSLRSDSSURSDSUSSSU.RLRDRSLRSLS", ".RLRULUSDUL.R.RUU.RSSSLRL.SSRDS.SS", "RLSRSSDDL.RSDDSSSSU..DURDSRLULUSUS", "SSSUD.SS.DSSURLRSDRLLSUUUDDSDRDRSL", "ULS.S.UU.RDDSSLSRUUURUSDSRURLRUS..", "DDL.RD.SDDULSU.SRSDSRSSLRUSUDD.RD.", "DLDSLUSDUU.RSSLS.RU.SR..DDRLRURLSL", "SDU.SDDS.SRS.DLULULRURD.RUSSDSLSUD", "UL.RLRURSSSL.USSLLSS.UUDL.RLS..SLS", "...ULDLL.DD.DL.DSLUL.RLSS.RSLSDL.S", "RDRDRUSRLSRDSRSUDLRSDRUSRSU.RLSDSL", "RLUUDSURLSDUSDSSU.RDRSDRSSLDSRURD.", ".DDDURSL.SS.SSD.DLRLU.USLRL.UD..UD", "LSRU.S.RSUSRLSSRLUURSD..RLRSSUUDLS", "RLDL.SDSD.RL.SRURSSU.S.RL.RSSSDULS", "USLULUURL..DLUU.SRL.RL.UUDSD.USRLS", "RSSLRSSUS.DUUD..SRUDUDLURRDRSLSUUS", "USSURL..DSL.DLDLRLDL.RUDSDSDRUUDSU", "DLRRUSDSLDSDS.SSRLS..RLSDLUSLRDSRD", "SSRU.ULRDSDUULUUSRLRDSUUUL..RURUSS", "RLSS..DUSRUDSUSDUUDUSSDLDL.DSLDDSS", ".SUSDDLLULDSSSLUD.SRLRUSUDDURURLRU", ".DDSSULDDSS.S.RDRSUUSSSU.SULUSLRSL", ".SS.USUULSUL.DSUDRSD..DSDSRRSLRLDL", ".RLU.RSSSL.SDU.RDS.RSDUDUU.DSLRLUL", "DSDSDLURSDDULRSUSSDD.SRUUDSUS.SULS", "S.RSU..RDRD.RURRLRURLRUDDSDLRLUSUS", "SRD..RSSLSRLUSDRSD..SRSUULSSUUDSDS", "UUSRLSDDSSSL..RSDS.DUSSRLLRUDSLRLS", "RLSSSSDUDSSSSLRDSULUDS.SS..DLLDURU", "RLRUUURSLD.S.RURU.USLRSLUSSLR.RSL."}

Returns: { }
{".DSL...DLDSSSSSSD", "DL.RD..SULDL..RLS", "RD..RSLULDLSRDUUS", "RL.RSDS.RL.SSRL.S", "USSUDLRSSLDLULSRL", "RSSDUSL..RU.DLSS.", "USSUDDS.RL.RUDUUL", ".RD.SUU.SS.S.SRSU", ".SS.UL..SRLUSUS..", ".UU..RSSLDL...SRD", ".DD.RDDSLRL.RSLSS", "RUS.RLS.RLS.USSLS", "SDLDL.RSLSRL.DSSU", "ULDUS...SS.USUDL.", "..UDUDDLSUDRLDLS.", ".DDS.SUURLSULSDL.", ".ULS.USSLULDLSS..", "...S....USDSRLUSD", "DSLUSSLDSSUS..RSU", "RLSDD.SSRDRLRLSRD", ".ULUL.UURLRSURUUL"}

Returns: {"./-\\.../\\/------\\", "//.\\\\..|\\//\\../\\|", "\\\\..\\-\\\\\\//|/\\\\/|", "//./-\\|.\\/.||\\\\.|", "\\--///\\--\\//\\\\|//", "/--\\\\-\\..\\/.//||.", "\\--//\\|./\\.////\\\\", "./\\.|\\/.||.|.|/-/", ".||.\\\\..|\\\\\\-/|..", ".\\/..\\--///...|/\\", "./\\./\\/-\\\\\\./-/||", "//|.\\/|.\\\\|.\\--/|", "|///\\.\\-\\|\\\\./--/", "\\///|...||.\\-//\\.", "..\\\\\\\\/\\|\\\\/\\//|.", "./\\|.|\\/\\\\|\\/|//.", ".\\/|.\\--\\\\//\\||..", "...|....\\-\\|\\/\\-\\", "/-\\\\--\\/--/|../-/", "\\\\|/\\.||/\\///\\|/\\", ".\\/\\/.\\/\\/\\-/\\/\\/" }
{"RSDSLU.RRSD.S..RSSSLDLRSSSSSSSDRLSRSDS..DL", "S.SRSDDSUDUDDLSUSLSULSRDDDRLDSLRLSULSDSDSS", "UDSS.SRLDSLRUUSSDSRSSU.UUSULSDSL...SUL.UUS", ".SRULUSURSU.RDDLSUU.RSDDLRSSLS.SDSDRD.RSSU", ".ULRL.DLDD..ULSSRDDSU.ULSDLDDUDSUSU.SUUDDL", "RSLUU.SSSRDRDLRUDUS..DSDRLRLS.SULDDRRSSLSS", "RDS.DSLSRSUSRSDRUDRL.SRUSRSLS.ULSRURLRDDLS", "UUSDSDRUUDDSLDUDSL.RSLSRRSRLS.SSUSDRLULRDS", "..RUUSUS.ULRDRDS.DSSLDU.RUSDUD.S..SDDRSLUL", ".LSRSL.RSLD.SSUL.S.DRUDLS.USSLSUSLSSSULUSL", "SDURSUDLDRSLS.D..RDDL.UURL.RDRD.RLSSS.RLDS", ".S.L.DLS.LDRUUDSSSUSSRSSDS.SRURDSDUSSRLUDS", "RSRL.SUDSSLLDDSDS..RURSLSSSUSD.RLSLSULRDSS", "LSSRLS.SRDS.RLSRSD.LDLSULRSD.SRSLUSLDSSLRL", "USS.SRLSSSUSL.SRLS..SSUDD.DLRLRLSRSDRSDRRD", ".SS.RSURUSL.S.RLSUSLSSRUSRL.RL.RUSRSRDUSUS", ".SUDRSL..RSDS..SRL.SULUSUULDSLDL.S.ULSRSLS", "RUDSRSL.DDDLRSLSSUSL..DDURUS.RLRLRSSDRL.RU", "DLRL.RDLSSRLRDSSRRUSDDSS.RSL.ULRSDLLUDDLRD", "SSDSSUSRLUSUUUSRSSDSUUSS.DSSSDUDSRLDDURUUU", "RLSS.SSS.URSSDUSSSLR.LRLDU.RDSRSSURLRSSSSD", ".DUSLRUUSSUR.RSD....DSDSUL.SRLLSRDRLDDDSSL", "RSSSLSRSDRSSDRDUD.DSL.RLDLSUL..RSU..SUU...", "RSSSLSS.SSDSURU.S.RD.S.UUUL.ULDSSLDRU.RSLS", "RSDRLUL.RLSDSL..SURUDSSSSLDSSUSRLUSL.RL.SR", "SDUUSLDDRDSSDSRLRLS.SRD..UUL..SUUDLRSLDLUL", "SUD.DRUULRUSUSSSDUSSSULSDDSRSSLS.RLSLDLUSL", "S.USDRLDLRLUSLSSS.SUS.R.SRLSS..DSL.USU.RLD", "ULRDSULSULS...RUS.S.SDL.SRURSSSLDUDL.RDRUU", "LSSSSDSURLUSLSDLULSDUSS.SSRSDRSDUSLS.SUDDD", ".RUSULDDUL.DL.RL.RLSRLRDRLRSUULRL.DUDSDURL", "DSLRDSSUD.DLDLDL.DDSUSSURSSD.DURLUSRLSUSL.", "SRL.SRL.SSULRLSULRLSDSSSUDSUDU.USDSSSRSLRL", "SS..ULRSLDDRDURDS.RURSLDDULSRSLDLSSRURSUSL", "SS.DLDURSLS.USSUSRURSSLRU.RSL.SRURU...DSDL", "SSDLSSSUSSL..DSLRU.UD.RSSLDLRSU..R.DD.S.RL", "SRUSULRDL.DSSU.SRSSSLDUDDSSSRDDL.RDRUSRSSU", "RDRSDDSLRDS.RD.ULDSSSL.UUSULUUUU.UURLRD..L", "RURSUULRSURLRL.DSLRLRDDSLSUSLRLDSL.UUULRL.", "S.DSSLSSLRDSRSLSRLSSRURSUSDSLUUUDULRDRDUL.", "RSU..UUUSURURSURURURSSSSSUUSU..RRSLRURUL.."}

Returns: { }
{"RD............DD........DDDSD....DSSL..", "UUDLRDRDRSSD.RUSRL..RSD.SSULS.RLDUDDUL.", "..SSULSSS..S.ULUUUD.S.RLSRSLS.SUU.SSDL.", "RDULDDRLS.DURDSRL.USLDSLRD..RLS.DDSSRL.", "SUSDRURDS.RDRURLS..DDSRL.SRSSUSRUSRU.RL", "RL.RL.SRU..USSLRLDSUULUL.SUSSDSRLRSL..S", "RU.DL.S..DSL..ULDLRSLDLDSL.RLSSRURLRL.S", "USLSDLUSLS.SDLRLUSLDUSRUDL.ULSSUDUU.ULS", "RLRURU..SS.UUSUURSSU.USSLUSSSUS.RLDLDUS", "UL.DDDL.SSRDRL.RUDDRD.RSL.DDRSL.RUSSS.S", ".RSURLRDRLRUS..RDUUSS.S.S.SULRSSU.SSS.S", ".UL..RSU....RLDLULRURLRDS.UD.UL.DDRLSRU", "..ULDU.RSSLRLSUL.SRL.S.SS..RDDU.SUSDSRD", "RSSUSDDRSSLRUSDSDUDRDSRURDRSUSRLS..RL.S", "S.DLSRU.DL.RLUL.S.RSUSS.DLUL.ULSSRD.DLS", "RDULS...SRLRU.RSU....SSDURLUD.RLULUSLRL", ".RD.USSSU.USSDS.RSD..SSRDSS.RDRD.RDDD..", ".DU......RSSSURDS.USSLS.RURSSL.S.SUURD.", ".RDDLRDRSU.RDRLUUDSSSLRSSLDLDD.SRL.DDS.", "..SSRLSS...SSRL.RLDL.USLDLULRU.SRLRLSS.", "DDSSRDRLDSDSS.RLS.UU.RLSRLRSSSLSDLRLSRD", "RURLSULRU.ULS.SSSRD..SSS.SSDLRUSS.RLUDS", ".DSSURLRSLRSU.SRLSUSDRLRLRURLS.UU.S..SS", ".S.RDRD.DLRL..USDRD.USL.S.RSLSDL..RSDSS", ".UDSRDUDUD.USL..S.SDSSL.SRLDLSSRSSSLSRL", "RDSUDUSLRL.RDRL.S.RLRSLDLS.ULSRSDRLSS..", "SSS.UL.RURLRL.USL..RL.UU.UL.SSRDSULUURD", "RUS.RU.S.SRSSSSDRLDLDSSD..USUSRUS...DUS", ".RUDL..RDUSDRSSLRLRDRSSURD.RSUDLRSD.RSL", ".SRL..RDUL.RLDD..RDRD.RSUS.SDLULRLS.DD.", ".SSRSDSRLSDDRUSDSLS.UDSRDUSURU.DUUU.RL.", ".ULUDRL.SSUUS.RLRDSDLRUSUD.DSSDS...RSD.", "DSDDLDSDSRD.S...ULRLUSSL.S.RSLSS.RLS.RL", "UDSSDURLS.S.RSLRLRL..DSL.SRDDUSUSLRU.RL", ".ULSUSL.RDS.RDSSSSUL.S.USURUS.RDDLDD.S.", "...USSSD.SS.SULSSS.SDL.....RURSLULRU.UL", "DSDRSSDUSURSURDUUUSUSRSDRD.S.SDSSSSSSDS", "ULSS..SRSL..RLRSLRSSLS.RLS.RLUU.DSD.DUS", "RUSUSSUS.UL.S.RSURDRLSRSSU..S...S.S.RSL", "RSL.RL.RSDRLS.USD.SULSUD.RSSLDD.SRURD..", ".RL.RURDRL.RUDL.RLRD.RLRLSRSDSUSLUDUUDL", ".UUDD.RURSSL.SS..RDUSDRDULUSLRL.DSURLUU", "RL.RURL.RSDUSLS.RDS.RL.RL.....RSL..SUSD", "SSDD.SUSL.SRDDLDLUURL...RLDSSSSSSSDSDDS", "ULSS.S....SRUUDRSL.ULDD..SRSSSSDDLRUULS", "DDRL.UDRSSLRSDS.RU.DLSUSDRSLRD.SSRSSSSU", "RL....RU...USLUSL..RSU..RSSLRU.RL......"}

Returns: {"/\\............/\\......../\\/-\\..../--\\..", "\\//\\/\\/\\/--\\.//|/\\../-\\.||\\\\|./\\///\\\\\\.", "..||\\/|||..|.\\\\\\/\\\\.|.\\\\|\\-/|.|\\/.||//.", "/\\\\//\\\\/|.///\\|/\\.\\-//-/\\\\..\\\\|./\\||\\\\.", "|\\-\\\\//\\|.\\\\\\/\\/|../\\|/\\.|/--/|//|\\/.\\\\", "\\\\.\\\\.|\\/..\\--\\///-/\\/\\/.|\\--\\|\\\\\\-\\..|", "//.//.|../-\\..\\////-\\/\\/-/./\\||///\\\\\\.|", "\\-\\|/\\\\-\\|.|/\\/\\\\-///|\\//\\.\\/||\\\\\\/.\\\\|", "/\\\\/\\/..||.\\/|\\//--/.\\--/\\---/|.\\\\/\\//|", "\\/./\\/\\.||/\\//.///\\/\\./-\\./\\/-/.//|||.|", "./-/\\/\\\\\\/\\/|..\\\\\\/||.|.|.|\\//--/.|||.|", ".\\\\../-/....\\\\/\\\\\\//\\\\\\\\|.\\\\.\\\\./\\\\/|//", "..\\\\//./--\\/\\|\\/.|\\\\.|.||..\\\\//.|\\-\\|\\\\", "/--/|/\\\\--/\\/|/-\\\\\\\\\\|//\\\\/-/|/\\|..\\/.|", "|./\\|\\/./\\./\\\\/.|.\\-/||.//\\\\.\\/||/\\./\\|", "\\\\\\/|...|\\\\\\/./-/....||///\\\\\\.//\\/\\-/\\/", ".\\\\.\\---/.\\--\\|./-\\..||\\\\||.\\\\\\\\./\\/\\..", ".//....../---/\\\\|.\\--/|.\\/\\--/.|.|\\/\\\\.", ".\\\\/\\/\\/-/./\\/\\\\//---\\\\--\\/\\/\\.|//./\\|.", "..||\\/||...||\\/.///\\.\\-\\//\\/\\/.|\\\\//||.", "/\\||/\\\\//-\\||./\\|.\\/./\\|\\\\/---\\|//\\\\|\\\\", "\\/\\/|\\\\//.\\/|.|||/\\..|||.||/\\//||.//\\\\|", "./--///\\-\\/-/.|\\/|\\-\\\\/\\\\\\/\\/|.\\/.|..||", ".|./\\\\\\.//\\\\..\\-\\\\\\.\\-\\.|./-\\|/\\..\\-\\||", ".\\\\|\\\\\\\\\\\\.\\-\\..|.|/--/.|////||\\---\\|\\/", "/\\|\\\\\\-///./\\\\\\.|.\\//-\\//|.\\\\|\\-\\/\\||..", "|||.\\\\.///\\\\/.\\-/..//.\\/.\\\\.||/\\|\\/\\//\\", "\\/|.//.|.|\\----\\/\\///--\\..\\-/|\\/|...//|", ".////..\\\\\\-\\/--/\\/\\\\\\--//\\./-//\\\\-\\.\\-/", ".|//../\\\\\\.\\//\\../\\\\\\./-/|.|/\\\\//\\|./\\.", ".||/-\\|\\\\|/\\//|/-/|.\\\\|/\\\\-/\\/.//\\/.\\/.", ".\\/\\\\\\/.||\\/|.\\//\\|/\\\\/|\\\\./--\\|.../-\\.", "/-\\///-\\|\\\\.|...\\/\\/\\--/.|.\\-\\||./\\|.\\\\", "\\\\||////|.|.\\-\\/\\/\\../-\\.|/\\//|\\-/\\/.//", ".\\/|\\-/.\\\\|./\\||||\\\\.|.\\-/\\/|.\\\\/\\/\\.|.", "...\\---\\.||.|\\/|||.|//.....///-/\\/\\/.\\\\", "/-\\/--\\\\-/\\-//\\\\/\\-/|/-\\/\\.|.|/------\\|", "\\\\||..|/-\\..//\\-\\/--/|.\\/|.\\\\\\/./-\\.//|", "//|\\--/|.\\\\.|./-/\\\\/\\|/--/..|...|.|.\\-/", "\\-/./\\.\\-\\\\\\|.\\-\\.|\\/|\\\\./--//\\.|///\\..", "./\\.\\//\\//.\\//\\.\\\\\\\\.\\\\\\\\|/-\\|\\-/\\\\\\//\\", ".\\//\\.\\/\\--\\.||..\\\\\\-\\\\\\\\/\\-/\\\\./-//\\\\/", "/\\.\\//\\./-\\\\-/|./\\|.//.\\\\.....\\-/..|\\-\\", "||/\\.|\\-/.|/\\////\\///...\\\\/-------\\|/\\|", "\\/||.|....|\\/\\\\\\-\\.\\\\/\\..|\\----\\/\\\\/\\/|", "/\\\\/.\\\\/--//-\\|.//.//|\\-\\\\-\\/\\.||\\----/", "\\/....\\/...\\-/\\-/..\\-/..\\--/\\/.\\/......" }
{"DSD.RSSD..RLDL..RL...", "SRL.UDRURLUURURLSUL..", "RLRSSUS.RLRSSLSSRDUSD", "..UD..SRL.UD.SSUDUSSU", ".DSLDSURU..SRUS.RLDL.", ".USDS.RSSDRUS.S..SSRD", "...SRSU..SUSL.SDLSRSL", ".DSL.RSSSUDSL.SSSSDD.", ".SRL.UD.RSU.SDLRLUUUL", "RLRLRDS.USLDLS.DL.RLS", "RSD.ULSDSSLUSL.SSDUUL", "DDS...UL.DSLRDDLRLRL.", "SSSRSDDSLUSUULS.DDRL.", "UURLDLS.USSLRLRDUUDD.", "RSL.USLRSL.UUS.RSSUUD", "S.SRLRDRSL.RLRSD....S", "USLULRL.DSDUUDDRSD..S", "RSL.DSSSLRLRLUL..RD.S", "SRU.UL..RL.RL.RSSLSRU", "UU...RSSL.DLDLSRDULRD", ".DL.DSSLRDRLUUSSSDSDS", "DUSDLDDULS....RLSS.RU", "S.RU.RURLSRSDDSDSRSD.", "RL..RL.UUULRUS.SS..UL", ".USDUL.RDRLRSURUS.DDS", "RD.SRL.UUSUDDSL.S.SRL", "ULDUSS...USURLRDS.RL.", "..RDRU.DDRDDDULUURSL.", ".RDSDSLSUUULS....SRSD", ".RUSUSLSDSSLSRSDDLUSL", ".DLUSSSLS.DUSRSURD.DD", ".SS.DSL.S.RDSDSSLS.UU", "DUS.S.S.S.RUSSRSUUSD.", "RLRDS.S.USL.RLS.DSDS.", ".RSUUDRDDSD.DDS.RDSUL", "DD.DLRLRL.RSUSRDDLUSU", "UL.RU.SDD.RLDU.UU.RD.", "RSSLRDSSUDRUUL..DLSS.", "UD.SRURUSS.DDRDRUSSRL", "RU.S..DSDS.RL.RUDLS.S", "USLSDLSDURSSD..RLRUDU", "..ULRUUU....RSSU.USU."}

Returns: { }
{"RSLDDDLRSSSSD.DSSSD.DSSLRSSDRLDDDLDSSSSDDD", "S.ULSRLUSSSLUSURSSL.S..SSRDSRLUURUUSLRSUUL", "S.RDUSDDD.RUDSSL....RSDULULUSSSSLRL.SS.DL.", "ULSRSSLSUDRLSRSSL.RLDDUDDL......SSRDSS.RL.", ".RLDSL.ULS.UUSRDS.SRURSLRUDDRSD.SUSLSSRSSL", ".RSUDU.DUS...RLUUDU.RSSDDDUUS.USURD.SSS..S", ".ULRUDLS.SRSSSSSDSDDUSDSRU..SDLRDRLRLUL.DU", ".DURSURURLS.RLDDSRLSDSLS.RSLUUUUUD.USDRSU.", "RURSLDDRLDL.SRLUUDSUUL.USU.S...RSL...SUSD.", "RSUDURURLUD.UL...S..RL..DSDRSL.RD...DU.RU.", "DSLRDDDRLRL.RL.RLRL.S.DDUDSDDS..ULRLUL.S..", "ULUSLSSSDLDLS..RU.S.RSUS.SSSSUDDDRLRLULUD.", ".SDL.SRLS.UUS.RL..S....USLSUL.RLRSSSL.USU.", ".SSRSURSU...SDURD.RL.RSSSLS...DD..DSSSSSD.", "DURSSLS.DLDDRU..RD.S.USL.SSRSSURSSU.DSSLRD", "RSSSDUU.RUSRSSDRDRSU.DSLRURUDL......SDSL.S", "RD..UDDLDLSRSDUUS..RSURSL...SRSDDSSLSUDRDS", "UL.DSURLUUSRLUL.S.RUDLRDRSSLUDDUUD.SRLULRL", ".DDSRSSL.DU.RLRSU.RDRUDUUSLS.UUDDS.SDL..DD", ".RLSSRSL.USL.SDSL..UDDUDL.SRD.DUSUSLRSL.UL", ".RLRLS.DL.RL.RU.SDSSLSRUUDUDRSL.SDSSSDRSL.", ".UL..USLUSL.....RL...UU..RSL....UL...USSU."}

Returns: {"/-\\/\\/\\/----\\./---\\./--\\/--\\/\\/\\/\\/----\\/\\", "|.\\/|\\/\\---\\\\-//--/.|..||/\\|\\/\\/\\/\\-\\/-/\\/", "|./\\\\-\\/\\.///--/....\\-\\\\/\\/\\----\\/\\.||./\\.", "\\\\|\\--/|\\\\\\\\|/--\\./\\/\\\\\\/\\......||\\\\||.\\/.", ".\\//-\\.\\\\|.\\/|/\\|.|\\/\\-/\\//\\/-\\.|\\-/||/--\\", "./-///.//|...\\/\\///./--\\/\\\\/|.\\-//\\.|||..|", ".\\\\///\\|.|/-----\\|/\\\\-\\|\\/..|/\\/\\\\///\\/.//", ".//\\-/\\///|./\\/\\|\\/|/-/|./-\\\\/\\/\\\\.\\-\\/-/.", "///-\\/\\////.|\\/\\//-/\\\\.\\-/.|.../-/...|\\-\\.", "\\-///\\/\\\\\\\\.\\\\...|..//../-\\\\-\\.\\\\...//.//.", "/-\\\\\\/\\////.//./\\\\\\.|./\\\\\\|/\\|..\\\\/\\\\\\.|..", "\\\\\\-/|||///\\|..\\/.|.\\-/|.||||\\\\/\\\\/\\\\\\\\\\\\.", ".|/\\.|\\/|.\\/|./\\..|....\\-/|\\/.\\/\\---/.\\-/.", ".||\\-//-/...|//\\\\.\\\\./---\\|.../\\../-----\\.", "//\\--\\|./\\/\\\\/..\\\\.|.\\-\\.||/--/\\--/./--\\\\\\", "\\---\\\\/.\\/|\\--\\/\\\\-/./-///\\//\\......|/-/.|", "/\\..\\\\/\\/\\|/-\\\\/|../-//-/...|\\-\\/--\\|\\\\/\\|", "\\/./-/\\/\\/|\\\\\\\\.|.///\\\\\\/--\\\\\\//\\\\.|\\\\\\/\\/", "./\\|/--\\.//.\\\\\\-/.\\\\\\///\\-\\|.\\//\\|.|//../\\", ".\\/||/-/.\\-\\.|/-\\..\\\\///\\.|\\\\.//|\\-/\\-\\.\\/", "./\\\\/|./\\.//.\\/.|/--/|//\\\\\\\\\\-/.|/---\\\\-\\.", ".\\/..\\-/\\-/.....\\/...\\/..\\-/....\\/...\\--/." }
{"......RDDSL.RSSSD.DL.RSLRD", ".RSDRLRUUSLRU...S.RU.S.SSS", ".S.RUUSSDRDRSSD.SDL.DLRUSS", "DL.....RUSS.RDRLRURDUSLDUS", "RD.DSD.USURDSUSLDSLRSD.UDS", ".USL.RSSSL.SS..SSDURSU..RU", "DSDDD..RSLRUS.RSLULRD..DSL", "USUSS.DLRDRLRDUDDDS.S.DUDL", "RDDLRLS.SS.S.USLULS.RDULUL", "UURLDLRLSUDSDL...DU..UDUSL", "RSDSSDLSS.RLSS.RSUDDDLSDL.", "RSLUURLSSDLDUS.SRSUSSSUUUD", "DSSSD.RUULSS.SDLRSLSRU.RSU", "S...USLRSDSS.SUSSSUS...UD.", "SRSL.DSL.RURLRL..RDS.DL.S.", "ULRU.SDL...DU.RSDUURLSRLS.", ".RLRDULULDDS.DD.RD..SUDSRL", ".S.SUD.DLSUUDLRD.SRDUSUS.S", ".USL.RSL.USSU..RSLRL...USL"}

Returns: { }
{"RD.DD..DSL...DSSL..DSSSSSSDRSSD..DLDSDDSD..", "SS.SRSDS.RD.RL..RL.SRSSSD.SRD.S.DUSRSUS.UD.", "RL.UD.RUDDUSL..DDSDLSRSLS.RSUDL.S.RDDSURSL.", "DD..RSSDRURDRLDLSUL.SSDUSRSL.USDUL.SRL.SDD.", "RLDL...SDDUUSRU.SRSSUSUSURLUL..S.S.RLUSLRU.", "DLSS.DSLUUDDRLDLUUDLRU.RSLS.RSDS.RSLRSLDD..", "SSSRDS.DSDUU.SRUDDRUS..UDRLRSLSSDD.RSDSULRD", "ULUSLRSL.USSSL..UL..RSSSL..RSLRURL...UU..RL"}

Returns: {"/\\./\\../-\\.../--\\../------\\/--\\../\\/-\\/-\\..", "||.|\\-\\|.\\\\.//..\\\\.|/---\\.|\\\\.|.//|\\-/|.\\\\.", "\\/.\\\\.\\//\\\\-/../\\|//|/-\\|.\\-///.|.\\\\/-//-/.", "/\\..\\--\\\\//\\/\\//|\\/.||//|/-\\.\\-\\\\\\.|\\\\.|/\\.", "\\//\\...|/\\\\/|\\/.|/--/|\\-/\\\\\\\\..|.|.\\\\\\-/\\/.", "/\\||./-/\\//\\\\\\/\\\\//\\//./-\\|.\\-\\|.\\-\\\\-\\/\\..", "|||\\\\|./-\\\\/.|\\//\\\\/|..\\\\\\//-\\||/\\.\\-\\|\\//\\", "\\/\\-/\\-/.\\---/..\\/..\\---/..\\-/\\/\\/...\\/..\\/" }
{"DSL.DSDS.RSL...RSD", "SDU.SDURLRSU.RDSRU", "ULDDSUDUUDSDLRURL.", "..RLRLRD.RSURL.RL.", "RL...SSSRLRDRL.SRL", "SSDSLRSLUURU.RLSRU", "ULS.SDDDSDDSLUUSS.", "DSLRLRURSUSDL.DUUD", "RSDRSDRSD.ULRDSRDS", "DSL.RUULSDDDUSSUUS", "SU.RL..RUSSSDUS..S", "SDSU.RSSSURUULUSLS", "SSDSDS..RSSLDURSLS", "RUSRLRSSLRLSUDSSDL", "DLSRSSSL.ULULRU.S.", "RLSDL..SRSD.SRDDL.", "L.RUUSLSUSUUULSRSL", ".DLDSSLUSLDSUDUDLS", ".RLSDSSD.SUDLRDSSS", "RSSURSSLLS.UL.SUUS", "SRDLRSSSLRDRD.RD.S", "SSSDU.RDRSLULDDSRS", "RUUU..UU.R.R.RLRSL"}

Returns: { }
{".DLRDRSL..DD..RL.DDDL", ".RUUUS.RLRURSLSSDUULS", ".DSSLSRLUL...SUUUD.DU", ".S..RUSSRLDSLSRL.RSL.", ".SRSLDUSRUS.SRLRSSSL.", ".SRSLSRU..RSU.RSSLDL.", "RL..DUS.DD.RSDSDDSS..", "ULDDUSU.SSDLDLRUSSSRL", "RLRU..RLULS.RDRDULRLS", "SRLDSDUL..SDDSSS.DSLS", "SUUULS...DURLUURDS.SS", "RLDDUUDL.SDLDDDLSRSLS", "RUUL.DURSURUSSSSSDL.S", "USSSDUDDLDSSLSRUSRURL", ".DL.ULRUULDDRL..S..UD", ".UURSLRL.RLUU.RDUSSSL", "DSSU..RU.UD.RDULRL.DL", "RLDDDLDL..RSUUD.RL.SS", "DURLSRLULDL..RLRSSSUS", "S..RUDDDUSRDDLDURDDLS", "RD.S.UUSRL.SUDS.ULUUS", ".RLS.DSURD.RLUL.DL..S", "RSURSLRLRLDSLDSLRU.RU", "USSLDSUUUDUDLSDU.DDUD", "RL.SUD.DDRLUUUL..SS.S", "SRDS.USURDSDSD..DLULS", "SDLRSD.RLUUS.USSL..RU", "SS.DLS.SSDDUSLDSSD.DD", "UL.ULUSLUUUSSLRSSL.RL"}

Returns: {"./\\/\\/-\\../\\../\\./\\/\\", ".\\/\\/|.\\\\//\\-\\||//\\/|", "./--\\|/\\\\/...|\\/\\\\.//", ".|..\\/||/\\/-\\|/\\.\\-/.", ".|/-\\//|\\/|.|\\/\\---\\.", ".|\\-/|//..\\-/./--\\//.", "//..//|./\\./-\\|/\\||..", "\\\\/\\\\-/.||////\\/|||/\\", "//\\/../\\\\/|.\\\\/\\\\/\\/|", "|/\\/-\\\\/..|/\\|||./-\\|", "|\\/\\\\|...//\\/\\/\\\\|.||", "\\\\/\\\\//\\.|/\\/\\/\\|\\-/|", "//\\/.//\\-/\\/|||||/\\.|", "\\---\\\\\\/\\/--/|\\/|\\///", "./\\.\\\\\\/\\//\\//..|..\\\\", ".\\//-//\\.//\\/./\\\\---/", "/--/..\\/.\\\\./\\\\//\\./\\", "\\\\/\\/\\/\\..\\-/\\\\.\\/.||", "//\\/|\\/\\\\/\\..///---/|", "|..///\\//|\\\\/////\\/\\|", "\\\\.|.\\/|//.|\\\\|.\\/\\/|", ".\\\\|./-/\\\\.\\\\\\/./\\..|", "/-/\\-//\\///-//-\\\\/.//", "\\--\\/-/\\////\\|//./\\\\\\", "/\\.|\\\\./\\\\\\\\/\\/..||.|", "|\\\\|.\\-/\\\\|/-\\..//\\\\|", "|//\\-\\./\\\\/|.\\--/..\\/", "||./\\|.||/\\\\-\\/--\\./\\", "\\/.\\/\\-/\\/\\--/\\--/.\\/" }
{"RD.DSSSSSLDLDLRSSSD.........RDUR..DL.", "RLDU...RSLULSULDSSL.DL.DSSL.SS.RSLSS.", "DSLRL.RLDLRDUD.UD...SRLS.DSRUSRL.SUL.", "SU.SRDSRLUUSRU..ULDSU.SRSSUUSLRSSUDL.", "UD.S.SUL...SRLDSDSRSSLUL.RL.DDRDRLSRD", "RL.S.RSSSD.SDUUDSRDRDRSU.UUDUSRUUUS.S", "S.DU..RD.USLUL.SUSUULRL.RD.S.SDD..RSU", "RSLRL.RUDSSDDURS.RSLDLULRU.UDSSRSSSSL", "U..SRSSDSRDRUU.SDU.SS.RU.DSDRLS..DSSU", "DSSU.DSUSSRSSSSLSRSUS.S..SDLDDUL.RDDL", "USSSDRDRLS.RSSSSURSDRLS.RLS.SRSLDSLSS", "RSSLUSURLRSLRSSSSSDRLSUDUSU.RL.RLRLSS", "SRDRL.DLSDD.S.DSDDU.SS.SL.DSSUDL.ULRL", "SRU.RDSULRURUDL.SULRLULSRSLDSSURSLDSD", "SD...SRL.RDRDUSLRSLSRLSSSDLS.RDRSLS.S", "S.RDDURUSSSDURSURL.SSRLUUSRURLS...USL", "S.SSS.RSDULRSL..RLRUS.RL.UDDU.SDDDSD.", "ULSRL.SRLDDRL..DL.UDSSUUU.SRSSURUS.S.", "RUUDRSDRLSULRD.UL.DUS.RD..RD.DD.DLRUL", "SDDSRLRDSSDLRURSL.RDULSRLRLRLSSURSURD", "SUUS.ULUUSULRSL.UL.S.SUSLUL.ULS.RSLRU", "S.RL.DU..RDUS.DDSSDURLRSDDSDRSU.RSLL.", "S.RSLS..RDSRSSLS.SUDUSUDUS.SUSLDSLRL.", "S...SRDRLRUSDSLRLRSURSLRLRDS.RLSDUSUD", "SDSLUSUSRL.SULRLUSL.ULS.RSLS.RSLULSRU", "SUDSDSSUSSRU.USUDLUDRLUSSL.SDSDRRURLR", "S.SUURL.SSS.RSD.RLSRLDDSLUSLS.USUDDDL", "ULS.RLSSSSS.SSS..DDDSDUSU.RLRLRSLULRL", "DUS.SDLDUSRDUDUSDSSRDRDDSSUSDLS.SDSL.", "RSLRLS.RSURU.USSUUUSS.RL.RLSUSUURL.SU", "DDDU.S.DDUS.DL.DSSSSL.RSLULUSL....RL.", "ULRD.SRRL.RDSSDL.RSD.RUDUDDRSLDSSLRDL", "RL.RDSDD..RLUUUD.RLS.SSSLUUSS.RSSL.S.", "UU..UUULRDRSD..RSSLS.SDL..DLRSLRSLDUS", ".DLURL..RU..RSSSD.DURUSRSDS.SDURSUUSL", ".RLDUUSLDSSSSSSDS.USL.SRSUSRLSDSSSSLS", "RD.S...UU.RSL.DURLDSD.SDDRLUSUSRSSDSS", "RL.UL.RD.DL.RSL..SS.S.SSSSRD.DURSLSSS", "UU..S.UU.UD.RD..DURSL.SSULSRDULDLSSSS", "RSSLRL..RDRLSS.DL..RSDSSDDSDL.ULSULSS", "RSSU.RSSURSUULDUSSSUUULRLRLRSSSSU..RU"}

Returns: { }
{"RLDD..", "SRUUSD", "RDDSDS", "DUS.RU", "S.S...", "ULULDL", ".RDSSS", "DSUSSS", "RLDLSS", ".UL.SS", "..RSUS", "RSLRDS", "SRDUUS", "UUS.RU", "DDUSU.", "UL.RSL", ".DDUSU", ".SSRSL", ".SSRSL", ".RL.DD", "DDRDUU", "SSUUDD", "UUDSUS", "DDSRDS", "RUULUL"}

Returns: {"/\\/\\..", "|\\/\\-\\", "\\\\/-\\|", "//|.\\/", "|.|...", "\\\\\\\\/\\", ".\\\\|||", "/-/|||", "\\\\//||", ".\\/.||", "../-/|", "/-//\\|", "|/\\\\/|", "\\/|.//", "/\\\\-/.", "\\/./-\\", "./\\\\-/", ".||/-\\", ".||\\-/", ".\\/./\\", "/\\/\\\\/", "||\\//\\", "\\//-/|", "/\\|/\\|", "\\/\\/\\/" }
{"RSSSLDSLDLRDRSSSSSSLDL.RSSDRSL.", "RSD.SSSSULRLRLDSSDDRURLRSSUULS.", "RSU.SRSUDDRLSRDRSLS.RUSDLRSLRUR", "SRDSL.RLRUUURDSSRSURSSLUUSRLUDL", "UDUDDLULS.RSLRUSSS.RSL.RSLSDLRL", "RLRLUU.RSDSRURLSUSLRRLSRSSLUL.S", "SSS.L.RU.SSDLULSLSULSDRDSSSSSDS", "USUDSLRDRLULS.DL.RDUULRURDRSDRL", "DLRUDUSSSS..RDRSLSSLRSLDLSSRULS", "RURSU..SRLDDRUDSLRLLSSURSLULSSS", "RRLDRSLS.SSSUSURDRSSUDS.DSSLRRL", "SRU.ULUURRUUDURRLRSSSUDLRSL.DSL", "RDRSSUDSDUDRRSDDSULRL.SRL.SDUSL", "RUSRSDSDURSDSRUSS.SSRLS.RSURSLU", "DLUURUUS.SSS.USL.DLRDRLDSLSSRUD", "SSRLRSDULUSUDD..DSRSLSDUSRSLRSD", "SSUURSULUL.DUULRRLRSDDLSLSLRDSS", "RLRLDDSSDSRLDLSSULUSUSRSLRLSRSL", "RDRUSSDSLUURSSSRDS.RLRUDLUUS.RD", "SSDLDRLDSSDSSSSULRLSRLDLDSLS.RU", "ULUUDSLUSSLRLRURSSUSDSULRSLRDDD", ".SRDRDSRSSLSDSLSDSDRLS.USLDDSRL", "RDSSLUUSRSLSRLSSSSS.UULRDULSRSD", "SUURLDLSUL.SRRLSUSLLLDSLRLSS..S", "RDDLULSSRRLSDSDRLDSSSUSS.USLRDS", "SULULRUSULRURDUDUL.USU.RSDDSUUL", "RDRSURLUSDDSDUSLDSL.RDLUSLSURLS", "SSUDD.USDRUSSRLLSDLRUSDLDSLUUU.", "RUDLRSSSLDSLSSS.ULDLRUULSDSLRSL", ".RU.SDSL.RSLSUUDDDUSSRSSUUSUSDS", ".RSLSSRLRUSLRDRDRSRLRUDSLDLDL.S", "DSDSSSUDLDSLRLRUDLULDLSRLSRLSDS", "RSUUUUSL.RSLRSSSLS..ULRLLRSSSSL"}

Returns: { }
{"DD.RSSSL.....DSSLRL.DSSLRL..RLDSD.DSSSSSSD", "SUSU...UDDSSLRSSLSS.UL.RUUSSURU.UDS.DSD.DU", "SRSL.RSSLUL.RDRD.RU..USD.RSSSLRSLSUSLRU.S.", "SS.RSU.DDRL..SSSDLDSSSDRDRL.RUS.RU.RDULRL.", "SRSDRSSUSS.DSURURLRD..UDULRSU.S.RSSLSRLRD.", "SRLSUD..UL.RLDSDDL.RD..SRLRL..S.S.DSUS..RD", "SSSS.S.RSSLDURLSUUDLUL.UU.RUDSL.SDU..S.RLS", "RUSS.S.S.DLSDDRL..RU.UD..RSSU.DLULRD.ULULS", "DSLS.RDRSLRLUURLRL.RDRLRDSDD..RURSURL.S..S", "S.RLRLUD.RURL.RURU.SUUDLSSUU.DD.S.DSL.USSL", "RSU.SS.S.S.RU.DSD..RL.RDSUSSSLRSU.S.DLDL..", "DSSSLRSL.S..DSU.RDDLRDDLS....RD...USLUURSD", "RLDSSSLRSUDDS.DSDSSSRLRDUSSLDLUSSSSL.DL..S", ".SSDDDUS..SSS.RDSULSRSLS.DDSRSDDLRLRDSUSSL", ".RURLUDSRLRLRSDUURLRSLSS.RLRL.SRLRU.UL.DSL", "RSSL.RUSSSRD..RSDRU.DLSS..RDULS.DSSDDL.USU", "SDLRSL.UUSSSRD.DUDDDU.RU.RUUDULRUDDRLS.RSL", "ULSDSSLRSURLRU.SRUUURSSSSL..S..S.SSRSU.ULS", ".RURDRUUL..RSDDLS..RUDSSSSL.RD.S.RUUSDRDSS", ".RSSUS..UL.S.RU.RL.UDRSSSSLDLUSUDSSSSLRUUU", "RL..RLRSLS.RSD.RSURDRSSSDDSUUSSSLRSSDDL.RD", "SRSLSRLRLSDL.S.RL.RLRLDSUUD..RL..RSSLSS.UU", "RSLULUSLRLRL.SDLSRSSUSUSSSU.DUS.DSD.RURL..", ".RLDSDRLRSLRDSUUSUL..RSSSSSSL.UDUDRLRSDUSL", ".RSU.SULRSUSSS.DL.S.DSSSD.RL..RL.SDUDDULDL", "RSSLRURDRD.RUSRUDLRSL.RDULUURSU.DUS.UL.SS.", "USSUSDUS.S.RDSRDSUD.RDUL.SRLS...SRLDD..SUL", ".RSSURLS.RLSSRSUUSL.SS...SULRL..RUDLSDLS.S", ".SDDDSUS.DLUU..DD..RURSSSUDSSURSSLRSUSULRU", ".SSSRSDRDS.RSD.UURLSRD.DSLRLRLS.RU.DSU.RL.", "RUSRSSLDURLULUL..SSSSUSL.S.SUUUSLRDUSL.SDD", "RSL..RLRD.UDS.S.RLRLUD.DDS.S.RSSSLUD.USURL", "DSSSDUL.S..SRDSDU....SDLRL.SDL..DSDUSSSSSL", "UDDSU.RDRSDSRUSRSD.DLSS.DL.ULRSLS.RLRSD.DL", ".UU.RLULDLRURSUDLS.RLUL.SS...SDURL.RLDU.S.", "RDDDSSDDSUSLDSLSSS...RSSLUSDDUS..S.DDRD.RL", "RUUURLULUSSLRSLUUUSSSL.....UL.USSL.UL.USSU" }

Returns: {"/\\./---\\...../--\\/\\./--\\/\\../\\/-\\./------\\", "|\\-/...\\\\/--\\\\--/||.\\\\.\\/\\--/\\/.\\\\|./-\\.//", "|/-\\./--/\\\\.\\\\/\\.\\/..\\-\\./---\\/-\\|\\-///.|.", "||.\\-/./\\//..|||/\\/---\\\\\\\\\\.//|.\\/./\\\\\\//.", "|\\-\\/--/||./-/\\/\\/\\\\..\\\\\\\\\\-/.|./--/|//\\\\.", "|/\\|\\\\..\\/.\\\\/-\\/\\.\\\\..|///\\..|.|./-/|..\\\\", "||||.|./--\\//\\\\|\\//\\\\\\.\\/.\\//-/.|//..|./\\|", "\\/||.|.|.//|/\\\\/..\\/.\\\\../--/./\\\\//\\.\\\\\\/|", "/-/|.\\\\\\-///\\//\\/\\./\\///\\|/\\..\\//-/\\\\.|..|", "|.///\\\\\\.///\\.\\/\\/.|\\///||\\/./\\.|./-/.\\--/", "\\-/.||.|.|.\\/./-\\..\\\\.\\\\|\\---/\\-/.|./\\/\\..", "/---/\\-/.|../-/.\\\\/\\\\\\//|..../\\...\\-/\\/\\-\\", "\\\\/---\\/-//\\|./-\\|||//\\\\\\--\\//\\----\\./\\..|", ".||/\\//|..|||.\\\\|\\/|\\-\\|./\\|\\-\\/\\/\\\\\\|\\--/", ".\\/\\/\\\\|/\\\\/\\-\\\\//\\\\-\\||.\\/\\\\.|\\/\\/.\\/./-\\", "/--\\.//|||/\\..\\-\\\\/.//||../\\\\\\|./--\\/\\.\\-/", "|/\\\\-/.\\/|||/\\.///\\//.\\/.//\\\\\\////\\\\/|./-\\", "\\/|/--\\/-/\\/\\/.|//\\//----/..|..|.||/-/.\\\\|", ".//\\\\//\\\\../-\\//|..///----\\.\\\\.|.\\/\\-\\/\\||", ".\\--/|..\\\\.|.\\/.\\\\.\\\\\\----//\\\\-//----/\\/\\/", "/\\..///-\\|.\\-\\./-//\\\\---\\/-/\\---//--\\/\\./\\", "|\\-\\|////|/\\.|.\\\\.\\//\\/-/\\\\../\\..\\--/||.\\/", "\\-\\\\/\\-///\\/.|/\\|/--/|\\---/.//|./-\\.//\\\\..", ".///-\\/\\\\-\\/\\|\\/|\\\\..\\------/.\\\\\\\\\\\\\\-\\\\-\\", ".\\-/.|\\//-/|||.//.|./---\\./\\..//.|///\\\\\\//", "/--\\///\\\\\\.\\/|///\\\\-/./\\\\\\\\//-/.//|.\\/.||.", "\\--/|//|.|./\\|\\\\|\\\\./\\\\/.|/\\|...|///\\..|\\\\", "./--/\\\\|.\\\\||\\-/\\-/.||...|\\/\\\\..\\///|/\\|.|", ".|/\\/-/|.//\\/../\\..//\\---//--//--\\\\-/|\\///", ".|||\\-\\\\\\|./-\\.\\//\\|/\\./-\\\\\\/\\|.//./-/.//.", "//|\\--///\\\\\\\\\\\\..||||\\-/.|.|\\/\\-//\\\\-\\.|/\\", "\\-/../\\\\\\.\\\\|.|.//\\/\\\\./\\|.|./---/\\\\.\\-/\\/", "/---\\\\/.|..|\\\\|//....|//\\/.|//../-\\\\-----\\", "\\\\/-/./\\\\-\\|//|\\-\\./\\||./\\.\\//-\\|.\\\\/-\\.//", ".\\/./\\\\//\\\\/\\-//\\|.\\/\\/.||...|//\\\\.\\///.|.", "/\\/\\||/\\|\\-\\/-\\|||.../--/\\-\\//|..|./\\\\\\.\\\\", "\\/\\/\\/\\/\\--/\\-/\\/\\---/.....\\/.\\--/.\\/.\\--/" }
{"R" }

Returns: { }
{"DL", "U." }

Returns: { }

Statistics

Problem Statement for "EllysRollerCoasters"

Problem Statement

Definition

Constraints

Examples