[Question]
  [
Unless you have a userscript that modifies the site's design (or even if so), you should have noticed that we have our site design!
[(It's November now)](https://chat.stackexchange.com/transcript/message/50642664#50642664)
So, to celebrate, let's make a program that retroactively applies this design (oversimplified, of course)!
So, the most important changes are:
* our new name is now Code Golf and Coding Challenges
* our site is no longer the default blue color and is instead a nice dark green
So, given a string, change:
* `PPCG` to `CGCC`
* `Programming Puzzles {non-whitespace} Code Golf` to `Code Golf {same-thing} Coding Challenges` (for example, `Programming Puzzles + Code Golf`, `and Code Golf`, and `& Code Golf` would all be changed to `Code Golf + Coding Challenges`, `and Coding Challenges`, and `& Coding Challenges`.
* `#abc` to `#acb` (swap blue to green and vice versa - just ignore the fact that green shouldn't logically become blue but I don't want to complicate the color shifting)
* `#abcdef` to `#abefcd` (same as above)
Note that for the color swaps, you should accept any hexadecimal digit from `0-9` to `a-f`. You can choose what case of hex digit to require, but it must be consistent and the same from input to output.
Your substitutions can be case-sensitive, and if not, please specify how the output works.
The substitutions should only happen when the string is surrounded by word boundaries (including the start of the `#`). In other words, each of the specified substitutions should only occur if the match is at the edge of the string or is bordered by non-alphanumeric characters (on both sides).
Standard loopholes apply. This is a code-golf challenge, so the shortest code wins!
# Examples
```
PPCG -> CGCC
Programming Puzzles or Code Golf -> Code Golf or Coding Challenges
PPCG stands for Programming Puzzles and Code Golf and its site color is #abf -> CGCC stands for Code Golf and Coding Challenges and its site color is #afb
The color #00f is much more intense than #5568ed -> The color #0f0 is much more intense than #55ed68
Programming Puzzles and No Substitution -> Programming Puzzles and No Substitution
No Substitution and Code Golf -> No Substitution and Code Golf
Programming Puzzles and no substitution Code Golf -> Programming Puzzles and no substitution Code Golf
Code Golf and Programming Puzzles -> Code Golf and Programming Puzzles
Programming Puzzles and Programming Puzzles and Code Golf -> Programming Puzzles and Code Golf and Coding Challenges
```
(for the last test case, it is important to note that the translated string could be translated again but the transformation must be applied *exactly* once)
# Important Update
(Thanks @tsh)
The `Programming Puzzles ... Code Golf` substitution rule can include the other rules inside of it (`Programming Puzzles PPCG Code Golf` is valid). In this case, you may choose whether or not the rules are applied, but it must be deterministic. I'm not requiring that you be consistent between `PPCG` and `#...` because answers seem to implement the rules in my list ordering which results in inconsistencies. This is just a clarification; I believe all current answers remain valid.
  
[Answer]
# [Ruby](https://www.ruby-lang.org/) `-p`, ~~165~~ ~~164~~ 159 bytes
It ended up being very similar to the sed answer, but it abuses Ruby's string interpolation to duplicate the hex group matching `([\da-f]{1,2})` within the third regex three times instead of needing to repeat the whole thing again.
* *-1 byte from @randomdude999.*
* *-5 bytes from leveraging @Xcali's Perl solution*
```
gsub /\bPPCG\b/,"CGCC"
gsub /\bProgramming Puzzles( \S+ )(Code Golf)\b/,'\2\1Coding Challenges'
[1,2].map{|i|gsub /(^|\s)#\K#{'([\da-f]{%d})'%i*3}\b/,'\2\4\3'}
```
[Try it online!](https://tio.run/##bY6xboMwEIZ3nuIUKwKapAmQRN09MHRBarc4lUywwRLYiDNDA7x6KbRKsmS87@7772/a9Hscc2xT2LI0SWjM0u16QWNKF84dNyZveFUpnUPSXq@lQA/Yxwp8j5pMQGxK6c@ey0IWTGg@pAUvS6Fzga5zCtbh@bXidder/j/V@@oZ@oS9k871TizjG3nultngu0v1Eg23tD2L3GEcnzQA08D9uzM3B7RcZwhy2jwTpuXD@JuURUBlBVxMOUkKgfBUOp/FjZDdTs64ai8FVKYRoLQVGgXYgmsgh8PxTWRAgjDayx9TW2U0jpv6Fw "Ruby – Try It Online")
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), ~~270~~ ~~285~~ 283 bytes
Thanks to [Neil](https://codegolf.stackexchange.com/users/17602/neil) for pointing out a bug.
-2 bytes thanks to ceilingcat.
```
#import<regex>
#import<string>
auto f=[](auto s){typeof(s)R[][2]{"bPPCG","CGCC","bProgramming Puzzles( \\S+ )(Code Golf)","$2$1Coding Challenges","B#(?=([\\da-f]{3}){1,2}\\b)(.+?)(..??)(..??)","#$2$4$3"};for(auto r:R)s=std::regex_replace(s,std::regex('\\'+*r+"\\b"),r[1]);return s;};
```
[Try it online!](https://tio.run/##bVBNj5swED2HXzGCqLEbstpkm6oKhEjlkGu07Q1Q5RhDkMBGtpG6i/jt6QDa5rKX5/l4bzzzeNtuSs7vXiV53eUCwkoZqwVrIudRY1qztwhJTau0DbUoxd@xP6fIr2QZOayzCopjkpEpMrS3b61QBTH0NcmSXda718slPru@G5/jGJ/rRatSs6ZBPVy69/daGAJp@msNlMQKvz6ruqDIXO6WWyyMvPjG6lrIUhis//TI6UiSNM3Zpsj6l4H2W383pOmVkqf1CeHp9IFI93DOt@WLOwSF0vOa@vBKzdHY/HCY7vqjRVszLojxH0WyStPV@qteuzjZpb5OthkNtLCdlmCCIbhX0kLDKkmo0zuLSTm5Fk7hbJEP@wisMNb07mwEuJ84AErD/@MnDnLBWCZzA7g3fKbB5kM0ZZU1YCorgKsaRZUBj12neb9vH0Xv@bkYO03Hb9AoLQDvENIIsDcmwdvvv/8Q@ajxCobDETnmQ@AsnMW4CuFKGgujk1/AwmE@jzqL2QKuOgthCBO4sIkQMCqIpeO7SuUqcIb7Pw "C++ (gcc) – Try It Online")
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), ~~153~~ 130 bytes
```
\bPPCG\b
CGCC
\bProgramming Puzzles( \S+ )(Code Golf)\b
$2$1Coding Challenges
\B(#(?=([\da-f]{3}){1,2}\b).+?)(..??)(..??)\b
$1$4$3
```
[Try it online!](https://tio.run/##bU49a8MwEN31Kw7sQSKpiZMmZCmGavBqaLeogxyfbIEsgaQsCfntrhRIu2Q5eF/3nseorVwW0Xcdb0VPeMs5Sci70ct51naE7nK9GgwUxNcKGOVuQGidUSzZy21ZJyLb@CSNQTtiIOKTFrT5oCcxyDf1c9vd2a1eb@@iZ9WqYbSqmufNP@ryvdwtS15AXhSD8/BXSrILQpR2CKCS8iqQxP/EA@kYIOiIcHYmhXSAQvaKfE9PpthsVKbny3mC2XkEbSPagBAnaaHY7w9HHH4B "Retina 0.8.2 – Try It Online") Link includes test cases. All substitutions are case sensitive. Assumes normal regex word characters are acceptable so that `\B#` matches only `#`s that don't follow a word character. Edit: Saved 22 bytes thanks to @tsh.
[Answer]
# GNU sed `-E`, 198 chars
```
s/\bPPCG\b/CGCC/g
s/\bProgramming Puzzles( \S* Cod)e Golf\b/Code Golf\1ing Challenges/g
s/((^|\W)#[0-9a-f])([0-9a-f])([0-9a-f])\b/\1\4\3/g
s/((^|\W)#[0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})\b/\1\4\3/g
```
Runnable using e.g. `sed -E 'the above'`; newlines can either be included literally, or replaced with `;` if you so wish. Both work.
@HyperNeutrino come on that word boundary rule is stupid. Look what I had to do in the `#` case.
Yes, I didn't even try. :P
+9 by @Value Ink
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 85 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
ì▀¼FΣ¼≤C╛╓ÄydîNû►┘Δ▲Bd♫|α╒oñFτ▒t!↑▌╩┘♦pMc6Hèé▄·│╝∙↔¥^4b5╠·9█&╨^╨♂═î£ε■å±«\┴J₧å♠Å≡z╜û♀
```
[Run and debug it](https://staxlang.xyz/#p=8ddfac46e4acf343bed68e79648c4e9610d9ff1e42640e7ce0d56fa446e7b1742118ddcad904704d6336488a82dcfab3bcf91d9d5e346235ccfa39db26d05ed00bcd8c9ceefe86f1ae5cc14a9e86068ff07abd960c&i=PPCG%0AProgramming+Puzzles+or+Code+Golf%0APPCG+stands+for+Programming+Puzzles+and+Code+Golf+and+its+site+color+is+%23abf%0AThe+color+%2300f+is+much+more+intense+than+%235568ed%0A&a=1&m=2)
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~123~~ ~~109~~ ~~105~~ ~~110~~ 114 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
žKISå_Å¡JεÐć'#QsžhA6£«sSåP*i3äćsRJ«ë"PPCG"Qi"CGCC"]J”–±ÇÀ”DU¡ćsε”ƒËŠˆ”©¡DVćDÁ2ôεðå}ćs_P*YyÊP*i”Âïªï”«s®ý«®ìëyXì]J«
```
+5 bytes fixing test cases like `Programming Puzzles and no substitution Code Golf` and `Programming Puzzles and Programming Puzzles and Code Golf`.  
+4 bytes fixing test cases like `color-#00f` (colors with something besides spaces/newlines surrounding it). Thanks to *@Grimy* for bringing this to my attention.
Case-sensitive. Hexadecimal values are with lowercase `abcdef`; `Programming Puzzles ... Code Golf` is in titlecase; `PPCG` is in full uppercase.
[**Try it online.**](https://tio.run/##hVHBSsNAEL3nK5bkIBQCRWnxKikUK0hqVfRQStomzUKyC9nk0IJQBQ3oRfQsWLQHTbEK9mgPO60XoR/RH4mbgtRKi5dlZt5782ZmKTOq2Izj8XBnuwTdCpzzTmEygOtRuKYU2Xhob2X5A4@YAPUU3oDHUcj2CjyCSNZ1LS8XsazlNU0uF6btu2n7lr9BCG0R5w54R3AnAxF/3sDV@P7rQoT8iXdyh6MwB6fr8C6cXqF7IngVPXXchEvhIUhwBn3@DP2EHzH@Ah88Em8PouYR9MrCPo5leTaApHu04Rmui0kD6UGr5ZgMUQ9ptG6iPHUsKWEh5hukzpAlkGUCAc4Vswz7DDHsm6hGHSHCDClG1ZL27Z@Kkk5bSdkNajZyqWciTHyTMBP5tkGQkslkN826tMptl6JSUGU@9gMfUyL9yRcnWtmFUMR@q@aKxW2W6Ff2/Pc@0uwAanIA8QmxqhKqOkar@Q0)
Definitely not the right language for the job.. Mimicking word-boundaries and replacing `Programming Puzzles \S+ Code Golf`, but not `Code Golf \S+ Programming Puzzles` or `Programming Puzzles \S+ \S+ Code Golf` without any regexes is pretty hard (to do short).. >.>
**Explanation:**
```
žK                # Push "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
                  # (NOTE: if '_' also count as word boundary, use `žj` instead)
  IS              # Push the input as a list of characters
    å_            # Check for each character if they are NOT in the string
      Å¡          # Split the (implicit) input on truthy values
        J         # Join each inner character list to a string again
ε                 # Map each word to:
 Ð                #    Triplicate the word
  ć               #    Extract head; push remainder and head separately to the stack
   '#Q           '#    Check if the head equals "#"
    žh            #    Push string "0123456789"
      A6£«        #    Append the first 6 letters of the alphabet: "0123456789abcdef"
   s      sSåP    #    Check if the characters of the remainder are all in this string
   *i             #    If both are truthy:
     3ä           #     Split the 'word' into three parts
                  #      i.e. "#ab12cd" → ["#ab","12","cd"]
       ćs         #     Extract head, and swap
         R        #     Reverse the remainder list
          J«      #     Join them together, and merge them to the head again
    ë"PPCG"Qi     #    Else-if the word is "PPCG":
     "CGCC"       #     Push "CGCC"
                  #    (Implicit else:
                  #      Use the word that's still there from the initial triplicate)
]                 # Close all if statements and the nested map
 J                # Join the mapped words together again
”–±ÇÀ”            # Push dictionary string "Programming Puzzles"
      DU          # Save a copy in variable `X`
        ¡         # Split the string by this
         ćs       # Extract head & swap; pushing head and remainder to the stack
ε                 # Map each substring `y` in the remainder to:
 ”ƒËŠˆ”           #  Push dictionary string "Code Golf"
       ©          #  Save it in variable `®` (without popping)
        ¡         #  Split the current substring we're mapping by it
         DV       #  Save a copy of this list in variable `Y`
           ćD     #  Extract the head and duplicate
                  #  (so the stack is: remainder, head, head)
 Á                #  Rotate the characters in the head-string once towards the right
  2ô              #  Split it into parts of size 2
    εðå}          #  Check in each part if it contains a space
        ćs        #  Extract head and swap again
          _       #  Check if all values are 0
           P      #  And check if this is truthy for all
          *       #  And check if this is truthy, as well as the head
                  #  (this means the current string has a leading and trailing space,
                  #   and no other spaces)
 YyÊP             #   Check that none of the susbtrings in variable `Y`
                  #   are equal to the current substring `y`
 *i               #   If both checks above are truthy:
   ”Âïªï”«        #    Prepend "Coding Challenges" to the duplicated head
          s®ý     #    Join the remainder by variable `®` ("Code Golf")
             «    #    Append it
              ®ì  #    And prepend an additional variable `®` ("Code Golf")
  ë               #   Else:
   y              #    Simply keep the substring `y` as is
    Xì            #    And prepend variable `X` ("Programming Puzzles") 
                  #    since we've split by it
]                 # Close all if-else statements and the map
 J                # Join the mapped substrings together to a single string
  «               # And append it to the initially extracted head
                  # (then output the resulting string implicitly as result)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `”–±ÇÀ”` is `"Programming Puzzles"`; `”ƒËŠˆ”` is `"Code Golf"`; and `”Âïªï”` is `"Coding Challenges"`.
[Answer]
# [Python 2](https://docs.python.org/2/), 240 bytes
```
import re
lambda x,s=re.sub,b='(?<!\w)',e='(?!\w)',h='([\da-f]',t=r'#\1\3\2':s(b+'#%s{2})'%h+h+'{2})%s{2})'%h+e,t,s(b+'#%s)'%h+h+')%s)'%h+e,t,s(b+'Programming Puzzles( \S+ Cod)e Golf'+e,r'Code Golf\1ing Challenges',s(b+'PPCG'+e,'CGCC',x))))
```
[Try it online!](https://tio.run/##5VBRS8MwEH7vrzgpmpbWsk3mhlhE@rDXgYIP1od0vTSBNBlJxpzib59Jt6kP@wcGQr67@77vLrfeOa7VZL8X/VobBwYjSfumpfCe29JgYTdN3pQkebi/qLcpyTHgA@QevtYtvWZvJHelIXE9rm/qCbmzSZOR@NJ@Tr5ScskznpEAfxOYu/xEOjHSI/ypLY3uDO17oTpYbj4@JNoE6qcMKt2mCAstGfFsQ3x8COtx4FacSomqQ0uORstqEZikWlQVyd9Tf/as/B8fjdZGKAcsCX/c2cK6VqjCIG0Tv4WgKM/0h@xqaH9oV8ALFxLBcQQtW1hpqQ0wf30mWIS3R9hSC/FkNZtNZ5AYvem43EF8M5um@aBVuAWtkNh4TOd0PB@NiugRGiM67o6mwjswZL4QBePo3Gye9jPawALrqGrtMNE5gS/@KoZIOAtWOPzTlTYseuanTDwasZDuNysOvTYIfouobFgCVRBPp7dzbL8B "Python 2 – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 174 bytes
```
s=>s[R='replace'](/\bPPCG\b/g,'CGCC')[R](/\bProgramming Puzzles( \S+ )(Code Golf)\b/g,'$2$1Coding Challenges')[R](/\B#(?=([\da-f]{3}){1,2}\b)(.+?)(..??)(..??)\b/ig,'#$2$4$3')
```
[Try it online!](https://tio.run/##fZNNb@IwEIbv@RUjBcm2CikfJWWFAlJz4Iq6eyNIdRI7uHJsFLt7KOK3szbZsJS2K8Vjzzszz7yXvNLf1BSN2NuB0iU78eRkkoXZPCeoYXtJC4a2@D7L1@t0leX3VR@lqzRFZPPcyo2uGlrXQlWwfnt/l8xgyH7eAcGpw8FKS07aud64N3Ka70x3VEqmKmY60FOIlwneZCUd8O1hciSHUX98zHKCo7ulC9Gyiw4mHC10uIfeBJHT/CXw5mCwAG8t@MIS6AYuds6Nl6StfDTV8oylqjTAXcdXSFe8wvhMWANGWAaFlm5IGAhpzjtf17yPc5/2f0vjefBr1ynhcMi9XL8VO6h1w0Aoy5RhYHdUQTidxjNW@vXXM3z4/xlWxrMghHDkvrE/k3N4aOP07xV39@PlMfv3@uGXXjEm40@MaXxJv2EEL5FtRI1JZPZSWIwyhUhU0z2WkCzgEBRaGQsb0WdbSEB2bX43IvNzWUsWSV1hcZNzp9xI7CZHAxS5H4BRix9jQoIjmZ/@AA "JavaScript (Node.js) – Try It Online")
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~177~~ ~~173~~ ~~162~~ 142 bytes
```
J::jb.z"\\bPPCG\\b""CGCC"." z¶NZI°Pÿúd(MÜ_BöIkxnqä'u)"." s6#~ÍN³=<nñu/GÎg"VS2~:J%"(^|\W)#%s\\b"*3%"([\da-f]{%d})"N$r"\1#\2\4\3"$)J
```
Here's a version without Pyth's string compression mechanisms (aka it's safe to copy-paste):
```
J::jb.z"\\bPPCG\\b""CGCC""\\bProgramming Puzzles( \S+ )(Code Golf)\\b""\\2\\1Coding Challenges"VS2~:J%"(^|\W)#%s\\b"*3%"([\da-f]{%d})"N$r"\1#\2\4\3"$)J
```
[Try it online!](https://tio.run/##hZBNS8NAEIYR7CX6F4Rl02JjSe1XghS9mENooSWgKGhU0mbzoU22ZjegUXvwKnrwJOjRH6AIPXgRkv9lTFK/DoWeZvaZ952dmeE5teK43Wwe98oBVNWeokhyEiCUZEmCZQiC@XC81N1rhS9K9BG968VcJ3oK7482o3HrJHw4C29y4WN47S6cRs/LPpdaiMiO5qLbbvi2sb7oRq/@qhzdmXBnqzZqtguweHip7nJsgaT/rNQTsK/qGm8cXBT0Kw528x5Uq6xaUxtqHea5dhynQzGKh01PcxzbNYHiB8EAEVAqAQnrCMh4YEwVYO@/IGkDCNVcnQAjqUwzJMU/R/ayKQHEpgj08SAx2QSwWs9gtq0fwlYqRoodv28BB3sI2C5FLkGAWpoLWEEQ15A@czzkEaaDqDZzDbZaqzeESch2Sm6TXUhLUcZNhv/N@UneEMRvp8hPlP@I@YmH1MYuiXn9Cw)
This ended up being really long because I tried to be as pedantic as possible with the regexes. I tried to compress every string possible, but most of them either didn't get smaller or couldn't be pasted into TIO properly.
Explanation:
```
J::                      # definition of J to the following 2 regex replacements
   jb.z                  # input to first regex replacement: all input lines joined together
   "\\bPPCG\\b"          # first regex
   "CGCC"                # first replacement
   ."<compressed>"       # second regex: "\\bProgramming Puzzles( \S+ )(Code Golf)\\b"
   ."<compressed>"       # second replacement: "\\2\\1Coding Challenges"
VS2                      # loop twice, N = 1 or 2
  ~:J                    # some weird assignment: J = regex replace in J (would be J := (regex, replacement) if : was python's regex replace operator)
    %                    # third regex: string format
     "(^|\W)#%s\\b"      # format string
     *3                  # repeat 3 times:
       %"([\da-f]{%d})"N # string format, replace %d with N (the loop counter)
    $r"\1#\2\4\3"$       # third replacement: uses python raw literals because it's shorter than escaping the backslashes
    )                    # end for loop
J                        # print J
```
* -11 thanks to a better regex from Value Ink's Ruby answer
* -20 thanks to using a loop for both of the hex replacements, inspired by the Ruby and Perl answers
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~152~~ 145 bytes
*@ValueInk saves 7 bytes*
```
s/\bPPCG\b/CGCC/g;s/\bProgramming Puzzles( \S+ )(Code Golf)\b/$2$1Coding Challenges/g;for$a(1,2){$p="([a-f0-9]{$a})"x3;s/(^|\s)#\K$p\b/$2$4$3/gi}
```
[Try it online!](https://tio.run/##bY5BS8QwFITv/RWPbQ4NWtvuWlHEUw49iFDQm1VIt2kbSJOSlwXZdf@6MV1RL3t88@abmVlYVXqPWdPWNauaNmMVY9lwf1KsGSyfJqkHqHf7vRKYQPN8ATRhphNQGdXTgJA1KYKw2NjIlRJ6EBgyemMJT4rLNT2Q@WGVvPK0z9O7twPhR7r62ISS5P2zQRo3j2T@Cbomm2yQR@@XOdGZBWAs/LVHiwvQcd0hhDo4B4TnP3G6pENA6QRsjQqQRIh520cv468S53m/yNNuO8JkrACpndAowI1cQ1yWN7ei@zKzk0ajT5/Kq7zIfTp/Aw "Perl 5 – Try It Online")
[Answer]
# Java 8, 192 bytes
```
s->s.replaceAll("\\bPPCG\\b","CGCC").replaceAll("\\bProgramming Puzzles( \\S+ )(Code Golf)\\b","$2$1Coding Challenges").replaceAll("\\B(#(?=([0-9a-f]{3}){1,2}\\b).+?)(..??)(..??)\\b","$1$4$3")
```
Port of [*@Neil*'s Retina answer](https://codegolf.stackexchange.com/a/186729/52210), so make sure to upvote him!
[Try it online.](https://tio.run/##rZJdT8IwFIbv@RUnZQltYAsfYlSCRHdBvBBJ8I5xUbYOil1H1o5ECb8duzHQAH7EeNO157zn3XlOu6Arai@Cl60vqFLwSLlclwC41CwJqc9gkB0BRjrhcgY@LjaKdEx8UzKL0lRzHwYgoQtbZd8qJ2FLYYrvhMDI86bDods3H1RDbt91ETnJJ/EsoVGUGQ/TtzfBFAbPG1WBYDcOGPRjEZKdg9W0GiaWSd05FYLJGVMnlve4jHtdPK7b19QOJ@vWhqwbtebGeBCn2iPYcXr7tfBtWBdWC5FtJ2NaplNhmAq0VcwDiMxoCvrxBCjZzUUzpTHKAFE@kUPkFAniBA40R2pTn/1MBgpCIztXbZIf5fmJawWKawZ@LEwRV1Cm0yPn5/k@Xa7Xw0wTpf4cojhh@SVLxUDPqYRyu315xYLTvjz5E4tR/GP/nvxbz5/fYn5hOULxXLlcprq4stGr0ixy4lQ7S5PUQmL0kOVvYE9/RlJBlWruUjW7r2XoKdW/sZKOj3dNfe9XoG227w)
]