C#

[".0s4*0|collections;datetime-format;.",["F]eEPS_a","HCLGNEHAHAIIRIOCNEMNPIPIHCKA","OOOCCSTUUUUTTUUUUYFRDADGDHDRDRDADFADADOCCPADGDHDRDRDFOCCPADGDGDHDRDRDGDFOIBOCBECPGDFGDRDOCCPADADFADADOCBCCPFADADADADOCCBCPRDFRDHDADHDADOBOBOWSTTUUUUTTUUUU","r.wrjr..y.ttsth..t.",".NET","Array","Dictionary","List","String","2D","Async","Console","DataTable","Dates","DateTime","Enum","File","For","Foreach","Format","IEnumerable","If","IndexOf","Lambda","LINQ","Optimization","Parse","Path","Process","Property","Random","Regex","Replace","Sort","Split","Static","Substring","Switch","Tuple","While","Replace."," A city can be changed. One building can be added and another destroyed. Think of this city as a string. We remove some characters and add new ones.","With Replace"," we search for (and exchange) one pattern for another. What was before is no longer. A change occurs and a new string is returned.","To begin,"," we call the Replace method. Please note that we must assign Replace's result to a variable. It does not modify the string in-place. ","Here: ","We introduce a const string literal. We call Replace() on this character data, and it returns a new string object.","WriteLine: ","We pass the \"output\" string to Console.WriteLine to print it to the console window.","ins","class","adsbygoogle","data-ad-client","ca-pub-4712093147740724","data-ad-slot","6227126509","data-ad-format","auto","br","ins","class","adsbygoogle","data-ad-client","ca-pub-4712093147740724","data-ad-slot","6227126509","data-ad-format","auto","Based on:"," .NET 4.6\n\n","C# program that uses Replace","\n\nusing System;\n\nclass Program\n{\n static void Main()\n {\n const string input = ","\"key tool\"",";\n Console.WriteLine(","\"::BEFORE::\"",");\n Console.WriteLine(input);","\n\n // Replace word (and following space) with a new word.\n // ... We assign to the Replace method's result.\n ","string output = input.","Replace","(","\"key \"",", ","\"keyword \"",");\n Console.WriteLine(","\"::AFTER::\"",");\n Console.WriteLine(output);\n }\n}\n\n","Output","\n\n::BEFORE::\n","key ","tool\n::AFTER::\n","keyword ","tool","Every instance."," This is important. The Replace method changes every instance of the specified substring. This can sometimes result in unexpected behavior. The first match is not targeted. ","Here: ","To demonstrate, the console program replaces the word \"Net\" with the word \"Basket.\" There is no need to call Replace two times.","Note: ","A second Replace() would not do anything. It would just result in CPU cycles being wasted.","C# program that causes multiple replacements","\n\nusing System;\n\nclass Program\n{\n static void Main()\n {\n const string s = ","\"Dot Net Perls is about Dot Net.\"",";\n Console.WriteLine(s);","\n\n // We must assign the result to a variable.\n // ... Every instance is replaced.\n ","string v = s.","Replace","(","\"Net\"",", ","\"Basket\"",");\n Console.WriteLine(v);\n }\n}\n\n","Output","\n\nDot Net Perls is about Dot Net.\nDot Basket Perls is about Dot Basket.","StringBuilder."," This is an important type. With StringBuilder, Replace works the same way as with strings, but we don't need to assign the result to anything. ","Here: ","In this example, we create a StringBuilder. We use the constructor to initialize the StringBuilder with a short sentence.","Replace: ","We replace the word \"This\" with the word \"Here.\" The result has the new word in place of the old word.","C# program that uses StringBuilder","\n\nusing System;\nusing System.Text;\n\nclass Program\n{\n static void Main()\n {\n const string s = ","\"This is an example.\"",";","\n\n // Create new StringBuilder from string.\n ","StringBuilder b = new StringBuilder(s);\n Console.WriteLine(b);","\n\n // Replace the first word.\n // ... The result doesn't need assignment.\n ","b.","Replace","(","\"This\"",", ","\"Here\"",");\n Console.WriteLine(b);","\n\n // Insert the string at the beginning.\n ","b.Insert(0, \"Sentence: \");\n Console.WriteLine(b);\n }\n}\n\n","Output","\n\nThis is an example.\nHere is an example.\nSentence: Here is an example.","Problem."," Replace() creates a string copy each time it is called. This can lead to measurable performance problems. MSDN notes that Replace returns a new string. ","This method does not modify the value of the current instance. Instead, it returns a new string in which all occurrences of oldValue are replaced by newValue.","String.Replace Method: MSDN ","http://msdn.microsoft.com/en-us/library/fk49wtc1.aspx","Rewrite."," It is usually easy to rewrite wasteful string Replace code with StringBuilder. Here I show the original code that uses string and then the new StringBuilder code. ","Version A: ","This version ends up creating many string copies. It replaces whitespace around punctuation.","NewLine ","newline","Empty ","string-empty","Version B: ","MinifyB is similar but uses StringBuilder. It does the same replacements as version A.","String Replace example: C#","\n\n","/// <summary>\n/// A - Eliminates extra whitespace.\n/// </summary>\n","static string MinifyA(string p)\n{\n p = p.Replace(\" \", string.Empty);\n p = p.Replace(Environment.NewLine, string.Empty);\n p = p.Replace(\"\\\\t\", string.Empty);\n p = p.Replace(\" {\", \"{\");\n p = p.Replace(\" :\", \":\");\n p = p.Replace(\": \", \":\");\n p = p.Replace(\", \", \",\");\n p = p.Replace(\"; \", \";\");\n p = p.Replace(\";}\", \"}\");\n return p;\n}\n\n","StringBuilder Replace example: C#","\n\n","/// <summary>\n/// B - Eliminates extra whitespace.\n/// </summary>\n","static string MinifyB(string p)\n{\n ","StringBuilder"," b = new StringBuilder(p);\n b.Replace(\" \", string.Empty);\n b.Replace(Environment.NewLine, string.Empty);\n b.Replace(\"\\\\t\", string.Empty);\n b.Replace(\" {\", \"{\");\n b.Replace(\" :\", \":\");\n b.Replace(\": \", \":\");\n b.Replace(\", \", \",\");\n b.Replace(\"; \", \";\");\n b.Replace(\";}\", \"}\");\n return b.ToString();\n}","Benchmark."," We next see if there is a difference between version A and B above. The version that avoids copies, with StringBuilder, is many times faster. ","Tip: ","Neither method is close to optimal, as internally each call to Replace must search the string.","Tip 2: ","This benchmark does demonstrate a clear advantage of StringBuilder. It does not show how to write a good CSS minify method.","Replace methods benchmark, 20 chars","\n\nMethod A - String Replace: "," 5.60 seconds","\nMethod B - StringBuilder Replace: "," 0.62 seconds"," [faster]\n\n","Replace methods benchmark, 1000 chars","\n\nMethod A - String Replace: ","21.80 seconds","\nMethod B - StringBuilder Replace "," 4.89 seconds"," [faster]","Argument performance."," Here we test a program that calls Replace in four ways. The first two calls use char arguments. The second two calls use string arguments. ","Note: ","Only the second and the fourth calls require that the string be changed in memory.","Char ","char","Tip: ","Avoiding an object allocation has a performance benefit. And often this outweighs any extra CPU usage.","Result: ","Replace calls that use chars are faster. And if no change occurs, Replace will return faster.","C# program that benchmarks Replace","\n\nusing System;\nusing System.Diagnostics;\n\nclass Program\n{\n const int _max = 1000000;\n static void Main()\n {\n string test = \"dotnetperls\";\n var s1 = Stopwatch.StartNew();\n for (int i = 0; i < _max; i++)\n {\n string t = test.Replace('x', 'y');\n }\n s1.Stop();\n var s2 = Stopwatch.StartNew();\n for (int i = 0; i < _max; i++)\n {\n string t = test.Replace('d', 'y');\n }\n s2.Stop();\n var s3 = Stopwatch.StartNew();\n for (int i = 0; i < _max; i++)\n {\n string t = test.Replace(\"x\", \"y\");\n }\n s3.Stop();\n var s4 = Stopwatch.StartNew();\n for (int i = 0; i < _max; i++)\n {\n string t = test.Replace(\"d\", \"y\");\n }\n s4.Stop();\n\n Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000 * 1000) /\n _max).ToString(\"0.00 ns\"));\n Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000 * 1000) /\n _max).ToString(\"0.00 ns\"));\n Console.WriteLine(((double)(s3.Elapsed.TotalMilliseconds * 1000 * 1000) /\n _max).ToString(\"0.00 ns\"));\n Console.WriteLine(((double)(s4.Elapsed.TotalMilliseconds * 1000 * 1000) /\n _max).ToString(\"0.00 ns\"));\n Console.Read();\n }\n}\n\n","Output","\n\n"," 13.00 ns"," Char Replace, no change\n"," 47.75 ns"," Char Replace, change\n"," 73.26 ns"," String Replace, no change\n","117.07 ns"," String Replace, change","Logic optimization."," Replace can be optimized. Suppose in our program many string replacements must be done. But often nothing is changed in actual strings. ","Version A: ","Let's look at the initial version of the method. It runs four Replace calls on the formal parameter to the method.","Version B: ","The second version uses the Contains method around all the Replace calls with the specified common string literal.","Contains ","contains","Tip: ","In version B, the first two Replace calls are only run when the common pattern is found. Often the string is searched less.","First version of method: C#","\n\nstatic string ","A","(string text)\n{\n text = text.Replace(\"<span>Cat \", \"<span>Cats \");\n text = text.Replace(\"<span>Clear \", \"<span>Clears \");\n text = text.Replace(\"<span>Dog \", \"<span>Dogs \");\n text = text.Replace(\"<span>Draw \", \"<span>Draws \");\n return text;\n}\n\n","Second version of method: C#","\n\nstatic string ","B","(string text)\n{\n if (text.","Contains","(","\"<span>C\"","))\n {\n text = text.Replace(\"<span>Cat \", \"<span>Cats \");\n text = text.Replace(\"<span>Clear \", \"<span>Clears \");\n }\n if (text.","Contains","(","\"<span>D\"","))\n {\n text = text.Replace(\"<span>Dog \", \"<span>Dogs \");\n text = text.Replace(\"<span>Draw \", \"<span>Draws \");\n }\n return text;\n}","Split."," Often strings contains invalid syntax. We can use Replace to fix incorrect parts of a string before using Split to separate it. ","Split ","split","Whitespace."," We often need to remove or change whitespace in strings, particularly those read in from files. We can handle tabs, spaces and line breaks. ","Whitespace ","whitespace","A summary."," As strings are immutable, Replace does not modify them. It instead creates a new copy with the replacements applied. It replaces all instances of a match.","For frequent replacement,"," StringBuilder is much faster. It avoids copies. Other than implementation, the methods are used in a similar way, with the same arguments. ","br","ins","class","adsbygoogle","data-ad-client","ca-pub-4712093147740724","data-ad-slot","3679700504","data-ad-format","link","br","ins","class","adsbygoogle","data-ad-client","ca-pub-4712093147740724","data-ad-slot","6227126509","data-ad-format","auto"],"url(data:image/jpeg;base64,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)","url(data:image/jpeg;base64,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)","url(data:image/jpeg;base64,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)"]

["url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKUAAAA+CAMAAAB9VCtoAAAAqFBMVEX////vr/Pnp+v8yP//+//+8/+9fcH+9P+HR4v93//+6v/7w//wsPSWVpr5uf3//f/91//dneGwcLT/+P/Sktb+9v/+7//95f+kZKj92v/zs/f/+f+8fMD8zv/80//3t/vIiMz4uPzxsfX92P/8y//lpen+8f/92//+6f/7xP/7u//94P/jo+f80P/7v/+6er78yf/ioub2tvq7e7///v/94v/93f/81f/LhO3yAAACkklEQVR4Xu3a146jQBAFUHcm5+TsyXlz+P8/2xnWlG0MvcBCyw99n6vRkbC5JcTsf+PgfUiPqZ/zfSzZIbM+NTzc2Af3mPrioL+Zy5Q2+veUVt5erFIrtVIrtVIrtVIrtTIgGOMd/0iIvbybclUpX2NKWTylMnAwL4xaIsykPmbdx6n4XCm/CiFu7KcHOo2ScKMlrtNKtOzrK2IKUVd+cxbmJEpstCdpU85RmxKhtWqlEQ5Qos0ESseQhTQrTZkSWeMriVTJm5WWVGmrVhrBACXKplBGnHP8Ho+U8cLCgOA2Jbl5jCn9XinvaHpQztV0TwJK3r17lqC0FTVkBMweDflSKZEipTNEea9amYOSdFdSUFpqlLMhytmESq3USkII7q30fT+bXsmIU67qLvi6KFe1hpxU6SUFsDor0yXs6iqUGIg9lC9vphDqlEE0YMPMPl0RlcrANfors8W1UiUrjP5KukVqleGpifNduWfKu2eDzpR3vu9P1j3MBY4bko7dQxcHpZLucUAT5Z27x0SVMl4pUSagCbo35BqUP9Q0JJxPevS4XSmXinoc+tDpoVxUSqpG2YaRK1Gl9JuUWuldstKF85f8u4Tz0ZD/eKxImbTccg+Uoex56Z8oGSg3U3WPWzEZwdw4xGWS7klX0OM0Pto2FnRUZX7kKRKMd/xskSucvKYUoGzbidDWFOMp4QLynF1AooSMqSRDlJZq5SwcoJxtmpRsQiWLmmWuAYnOlPT5Xfmrrgxs76B8Hvd7IrZrIIYBC2VvWunt9umhpswsQX+D0h5RWcaLTojRfmkPElA25PEtyI6Ur9QvBdl6GmUJKh9BLucJJuwgYR7mvABlLalYxqlI43j5IYTQfG7bW1COkD8/upOVozMCaQAAAABJRU5ErkJggg==)","url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAKoAAABRCAMAAAB1/c1qAAAAMFBMVEX////r4PTz6/n28fr59vzn2fbdyPDv5fb8+/7TuOrs4vXPrO3Xve3Ssu77+f3+/f7PhED1AAADHUlEQVR4Xu3Z226jQAyAYZ/mwPn933YbrdIKPINhiiPQ7n/Z9OITOBkj4DZlJkqIiVjAjrq9EBxjwp96yvAq4U98hhodoQnX9S+ZYCu1E/BpTqijBaidiuASY7E0Yzs1gEeEVjZVl+HyloQu1OQh9aEGh7vvRB0dvlFO1I7g0gRbqbY2OAxqMzV8cAIYf0UdVzJlZbiujIUSiwinA1RaSYPrBBDWQdKb1BUukOcE5N2BnLdW3r3/BKPjysL78ygGlTfnaHBcWXolTXo+6lTczCX5La2CKtH/UKfGzQXMfksrGRcVoN+jikIFt5UlmecR7VGTutXJ68BaUDXDOt6jBmUSr6VVjPtvUHPhYIpOE8CKSnAiKhz36DQBbIyqUSiI2OnAonaqPqrUH9+RD1XgeFT89tgry2A0xhgoX0oNRY+9sgyHipivo47ls95cWoeDTSFfROUVJ36nqaFMtev4Gip2R4ut1GHCS34BYnc4aaUOE19wBEh3PGymDl2VmuBo6QQ1tlOHUF1Xc8NRZZcNqn1ZZzw4rPMCm3J3ptROHXjveUVLezr1GsBeWcLGE+lVivUJIFRxSYpIxv03UtSyB7BKZVT1S0m6sqozKeC62spiUyEoaqw+BmDaWKVXU1xbVcBaWWxqrlGBTCvjOzZXFXNlsakQa1TBQkngnST8ic1VBeyl1abWPkpYinh+OTlVnhG5dm7aE9BOFTxRPwMwfbWijPSK4ZUQ/Xyu/0kaqATv6KQ11g9Pe91CmzptqfBd7vFE7E3F0reqZQQInKmsLqq0vWEhcKLWD9bQ9t6KwYlaLwI0WHuGT1MnbHrNkjL4U/UTq06SfUk/TY2VPX/hHutRBn+qbgpQLHNvQN2pupGh2MKEqsQLXF84/XSttcKU8B0xZ9D5U/UOUAd/NYPKjxrD30ZNnTJ8tqOrNWlsvCkVsrbKTakgihruStXL9XhbKg7bbkslRaV/ifqfGp5D7R5DDcPtfwHq0umOVMFoPAt+tuFs+BjqlB9DDfAUapefQp0YHkKdCB5CHRmeQe0Q4AnULiaAu1NjjCEJ/LY/AVWt4P/143sAAAAASUVORK5CYII=)","url(data:image/png;base64,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)","url(data:image/jpeg;base64,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)","url(data:image/png;base64,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)","C","url(data:image/png;base64,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)","url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAPoAAAChCAMAAADZe1I7AAAAMFBMVEX///9v8Zdw7/GK8vSs9vdFnGBdzH/K+foBAQFfX1+MjIy3t7f09PTV1dUnXDjq6uqKpVsyAAADc0lEQVR4XuzYMU5EAQwDUZdjJ1nuf1uKFUtJi+Q/N3hyquif9zT2lMoBOu0GQHWtb+CGXJ0cDrJAmX0ABQaisibkYCZan7oCwJKu8uaJtKbP/sKrNRhOda3BO7gPbsAXUFkD+ACiSZ399BWyMm127+8BRI0N4GmVd8LdKtevXBNVtcaalaRQaMcrHZBts5O3/BV1tc5n83PZ7prwM32ZXX7LFdJmX/OSJN3RZ8+bDn32jzyDV2XNAVkTqfNZmaiuQCRp1VewWsvpj56enp6+2bXD1QihGIjCUAWBcMj7v21LgWBjvWsDE6V75+8Ghs91FTfahZwsP1+lVlaqqqjK9G1bh9m2Ir1S1Uxf12WQda3SC1XN9JCf2ov0SlUzfVk+BlmWKr1QVaBP+qSzj5bOz6jp+FfALGiZ7hEX0z0FKT1QBG1A9yZ6REPPrEt0mumo6PgFutFFjypATfc/072FvisV0QmwMaB/k2O2iW7ab32v4QXd+D/0fE6NL3PEdO8Jb1I6Y3p80EiPIKJ70HOO9HSkmuiYlm5jOonuHfTIrXTPab2v+6Po6On7o3Dfbx0/pIduSjqJwjkdAO6gu5ROIH+h7ydivoOOkB4UJ1wHOvt6+ughR0Nn8PiSBtJww0OriH5e9Ti6iejZjj2MjqnoCYQ9ig7avyUJEu+4ggCYK4hJn+vGuWSerxa8yQsln+zKIQEAAACAoP+vLc6AzBUAAAAAAAAAAAAAAABqx45WKwSCGIBygYR5yv9/bkEJ3WKhGWnZtXfzJhjwMDjivoLcrN1s/V42fdM3fdM3fdM1JKRDQwC26FBViS8e5an0GsKMrvoaMabTXeBoLkNHl+4gpGPorEXXXXpldNRSdI4QRnTyLAhwmQmdtRj9VJwChBv+824XEzoMJjWd7ucRPIUuHfnUOS4GzaZ7bGCZ8Hd0jHuBq6w5enWhSWeZ8AP98m7MpnsUHkkppDtuJfQyfchk+ji+ukMXO3SuQvcgrGGL7uCBdF4ROV0AXHseHeU4zQ1P1/I1twhdFzp7dO9HxnSZi4l0z0xn7LlFR/5dhy81k+4/x8GgJl0Z3S33qKrSRLosGDYeO3TCrYCOclRnMItejowxqfHTGq6574v6B3REdF7kz6cjPaBS0HoOXULjWBIuC3y/w2gCAPc5/HvQN33TN33TPwB4AwzIIsAv2wAAAABJRU5ErkJggg==)","url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAPoAAACrCAMAAAB44HFdAAAAwFBMVEX////4/fr19PWMjIzP0M/9/Pzf39/p6un+9/m1trXq+fT2/Pn+7/Tw+vZfX1/78vb6/fvs+PP3+fj6+vnz+/j1+fjq+PP++fv+//73/fjt+vX69Pf39vf//f7//v7q+vT9/f79+en+/ff/+/3h9+3k+fLn+fP/9Pj/8/j+/v7+/P3o+PD5/vzt+er+/v/p+fHx+/D9/Ob1+/H8/e3+++/89vn++/D+/Pbj9+/+9vr7/fn+/vj9/v3//vz9/////vql2+EKAAAEpElEQVR4Xu3Y146sSBCE4Sk87cfbY9Z77/37v9WS0BULRagFOjvSZJH/zfTtp+5IwZzxXr9zdzP6m/Y17ez5MjrL6EY3utGNbnSjG93oRje60Y1udKMb3ehGN/qzI/+ivT+j32n303LSlzQ+g89o+ujOLZTu3ELpzi2V7pZKd26pdLdYuptEb0TR0d1kuhQT3U2lo1jojtMP/TwdRUF3jH5gvR3q4qQfOF3q+5XT3Sx6qF8OneD10t0sOsMviI6WSEdLpKMl0tEC6Sg2errb7RJCZ/1/9H9oP9Leo31P+4b2xvfQtW1b1w09Wwfl0mVYnuefj+O2l0zfHulFQ68ZXRrRc710yEE/b+hp63XI5Sik5/rpW09fy9jhBp3h87ZY6FfrduyFI3QEepc+OpGDngVPOHkQ6G1R0K8aenvnoAad2HOfYjrkQl/LnQMcdGLPUSR0J3fuENBJ8dGda+9cQGc1dKSdftXRMxl79HTIQXfOlTJ2Qj9ZHHQ3ohe7rizPizrdpXUSGf1Koi9v9ZGeFOmuq6B2/XSRZn26B9c7VMRI737fdUAPS+OkJ8HYS+/NyrxMsfugKOiH4KEm6w/cn7w6TnotzvGV64j4xUdLz4KpAxvtty7y8M4NsGW8W/fYlDzQSL3hB02j39F+oXHkd7SvaB+G/Sp9JH0srVardvTCv2iTO3fhA/ZS8sNvPt72qqrq+OkV7UXQpR5dGtHFl3k6sG1++LHSM5m2pwPb5ocfK70UqqcDK/nhF7rpEqcLNw2mngVTj42+7f3Ik+HUkz49jYYudtBx59jUU0xdGR2douPOEXqCX/+IfquSjrGDnmDsJb9y2unSmI6xn3qgiYi+CuhiLEYPNKCXAb1STRf7kJ4Npw66lKalPjofe0gv/J3D1LF1nD21dP6Lv74YPtQUOOl4hMf2ydSV0ls76GIMrpxU0Gf4SitdAj0YO66cr6yb9afZpU46H3tnvxb76OXtkkbkiugSoePlLXI6brzYr2GfQGfySiN91dJhx8tbdHRuBx137gSdyhXTpdGd43QiP0Wf/8/on2k/0L6lfUG7ubk5Pz9fPbRtfU9d/uWth/xp0GNTVf0mfSLJn64PaN74wugS6MeOYz/SIe7L914uQa6IvgroyL+8SVS+J3IldPq1J0+od+cYXOiQ66VLI3rx350jctAhV0aHHfSeXe5c96nvhnxP5Ero9GtPena5c6AHcInKP1VDD+0J7P3AFjjCiYuETu1ChhtRuQo6tSddlL4PYnJtdNiFzvBgDyJyPXSsHSUJw+9puHB66bCDjk7SiVwJndoTGqcTuS465j6fTuDK6LDPo2+IXBcd9pn0zYbIldFhn0PfNBG5HjrswE+jb9oIXB8d9kn0zTHIVdNh5/SBG0Gulg67xOlgDwL83el3ND6DP2j3tDXtgvZI29DwNDdoEXTIl0eHVg3d6EY3utGNbnSjG93oRje60Y1udKMb3ehGn9GscfD+pOW0W1pFu6W9ooHz4uhGN7rRjW50oxvd6EY3utGNbnSjG93oRje60Y3+/L2eEecoQBrd6EY3+oSMbnSjG93oRje60Y1udKP/C188AzCxaixPAAAAAElFTkSuQmCC)","A","url(data:image/jpeg;base64,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)"]