[Question]
  [
The cops thread can be found here: [The Mystery String Printer (Cops)](https://codegolf.stackexchange.com/questions/60328/the-mystery-string-printer-cops)
# Your challenge
* Choose a submission from the cops thread, and print out the string from an answer in that thread.
* The submission that you choose must not be safe (it must be newer than 7 days).
* Your program, function, or REPL script needs to follow the same rules as the cops thread. Just to recap:
	+ Your program must be ≤128 characters (if a cop's submission is in a smaller range of program lengths, your program must also be in that length range. For example, if a cop's program is ≤32 bytes, your program must be ≤32 bytes).
	+ The program must produce the same output every time it is run.
	+ No cryptographic functions.
	+ The program must not take input.
	+ No standard loopholes.
* All new submissions must use the same language. Submissions from before this rule was made are fine, even if they don't.
## Scoring
Scoring works similarly for robbers, but it is slightly different:
* Cracking any program of ≤8 bytes gives 1 point.
* Cracking a ≤16 byte program gives 2 points. ≤32 bytes gives 4 points, and so on.
* Every additional submission, no matter the length, earns +5 points
* Each cop's submission can only be cracked once- only the first person to crack each submission gets the points.
# Submissions
Each answer must include 
* A link to the cop's submission.
* Your program and programming language.
* Also have the cop's program length (as a power of 2) as the last number in your header.
Additionally, please comment on the cop's submission with a link to your answer.
Here is a Stack Snippet to generate leaderboards. Please leave a comment if there is a problem with the snippet. If you would like to see all open cop submissions, see the snippet in the cops' challenge.
```
/* Configuration */
var QUESTION_ID = 60329; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";
var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk";
/* App */
var answers = [],
  answers_hash, answer_ids, answer_page = 1,
  more_answers = true,
  comment_page;
function answersUrl(index) {
  return "//api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}
function commentUrl(index, answers) {
  return "//api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER;
}
function getAnswers() {
  jQuery.ajax({
    url: answersUrl(answer_page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      answers.push.apply(answers, data.items);
      answers_hash = [];
      answer_ids = [];
      data.items.forEach(function(a) {
        a.comments = [];
        var id = +a.share_link.match(/\d+/);
        answer_ids.push(id);
        answers_hash[id] = a;
      });
      if (!data.has_more) more_answers = false;
      comment_page = 1;
      getComments();
    }
  });
}
function getComments() {
  jQuery.ajax({
    url: commentUrl(comment_page++, answer_ids),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function(data) {
      data.items.forEach(function(c) {
        answers_hash[c.post_id].comments.push(c);
      });
      if (data.has_more) getComments();
      else if (more_answers) getAnswers();
      else process();
    }
  });
}
getAnswers();
var POINTS_REG = /(?:<=|≤|&lt;=)\s?(?:<\/?strong>)?\s?(\d+)/
var POINTS_REG_ALT = /<h\d>.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;
function getAuthorName(a) {
  return a.owner.display_name;
}
function process() {
  var valid = [];
  var open = [];
  answers.forEach(function(a) {
    var body = a.body;
    var cracked = false;
    var points = body.match(POINTS_REG);
    if (!points) points = body.match(POINTS_REG_ALT);
    if (points) {
      var length = parseInt(points[1]);
      var crackedpoints = 0;
      if (length > 64) crackedpoints = 16;
      else if (length > 32) crackedpoints = 8;
      else if (length > 16) crackedpoints = 4;
      else if (length > 8) crackedpoints = 2;
      else crackedpoints = 1;
      valid.push({
        user: getAuthorName(a),
        numberOfSubmissions: 1,
        points: crackedpoints
      });
    }
  });
  var pointTotals = [];
  valid.forEach(function(a) {
    var index = -1;
    var author = a.user;
    pointTotals.forEach(function(p) {
      if (p.user == author) index = pointTotals.indexOf(p);
    });
    if (index == -1) pointTotals.push(a);
    else {
      pointTotals[index].points += a.points;
      pointTotals[index].numberOfSubmissions++;
    }
  });
  pointTotals.forEach(function(a) {
    a.points += +((a.numberOfSubmissions - 1) * 5);
  });
  pointTotals.sort(function(a, b) {
    var aB = a.points,
      bB = b.points;
    return (bB - aB != 0) ? bB - aB : b.numberOfSubmissions - a.numberOfSubmissions;
  });
  pointTotals.forEach(function(a) {
    var answer = jQuery("#answer-template").html();
    answer = answer
      .replace("{{NAME}}", a.user)
      .replace("{{SUBMISSIONS}}", a.numberOfSubmissions)
      .replace("{{POINTS}}", a.points);
    answer = jQuery(answer);
    jQuery("#answers").append(answer);
  });
}
```
```
body {
  text-align: left !important
}
#answer-list {
  padding: 20px;
  width: 240px;
  float: left;
}
#open-list {
  padding: 20px;
  width: 450px;
  float: left;
}
table thead {
  font-weight: bold;
  vertical-align: top;
}
table td {
  padding: 5px;
}
```
```
<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="answer-list">
  <h2>Robber's Leaderboard</h2>
  <table class="answer-list">
    <thead>
      <tr>
        <td>Author</td>
        <td>Submissions</td>
        <td>Score</td>
      </tr>
    </thead>
    <tbody id="answers">
    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr>
      <td>{{NAME}}</td>
      <td>{{SUBMISSIONS}}</td>
      <td>{{POINTS}}</td>
    </tr>
  </tbody>
</table>
```
**This contest is now closed.**
**Overall winner: kennytm**
**Most submissions: Sp3000**
(Note that the amount of submissions doesn't translate exactly to the points, as the length of the cracked program is counted when calculating the score).
  
[Answer]
# [Pyth, Dennis, ≤ 8](https://codegolf.stackexchange.com/a/60342/21487)
```
V./Tp*FN
```
Damn that was fun - the hardest part was figuring out how to do it short enough in Pyth.
### Analysis
The `1234` at the start hints that we're probably dealing with a list of numbers, printed without a separator. Let's try and split the numbers up in a way that makes sense:
```
1 2 3 4 4 6 5 8 8 9 6 12 10 12 7 16 16 18 12 15 16 8 24 20 24 14 27 18 20 9 32 32 36 24 30 32 16 36 21 24 25 10
```
There's a few hints that we're on the right track:
* All numbers have prime factors less than 10
* A lot of numbers are pretty close to their index in the list
However, there are a few peculiarities. The number at index 23 is 24, and is the only case where the number at the index is greater than the index itself. However, the bigger clue is that some numbers are clearly smaller than their neighbours, particularly the 7 at index 15, the 8 at index 22 and the 9 at index 30.
Noting that this forms a 7-8-9 pattern, we can also see that the last number is a 10 at index 42. Given @Dennis' recent question on [abelian groups](https://codegolf.stackexchange.com/questions/60288/counting-abelian-groups-of-a-given-size), a quick check on OEIS reveals that `15, 22, 30, 42` is a subsequence of the [partition numbers](https://oeis.org/A000041). Pyth has a builtin for partitions, which gives us two of eight characters: `./`
But note that the last number is 10, which is suspicious because 10 is a preinitialised variable in Pyth, as `T`. `./T` gives a full list of the 42 partitions of the number 10, which looks like it might come in handy.
Now the printing is done without a separator, so this hints at a use of `p`. Perhaps we loop through each partition, do something to it, then print with `p`? This gives us the following template:
```
V./Tp??N
```
where `V` is a for loop which loops over an iterable, storing each element in the variable `N`.
A quick look at the second last partition `(5, 5)` should make it obvious that we want to take a product. The naive way to reduce a list by multiplication is
```
u*GHd1
```
where `d` is the list in question. However, this is far too long.
Unfortunately, this is where I had to pull out a brute forcer. I haven't kept up with Pyth for a while, so I didn't know many of the newer features. There were only two characters left, which looked entirely doable.
The brute forcer then returned:
```
V./Tp*FN
```
where `*F` is fold by `*` (multiplication). No wonder I didn't find it in my search - I was looking up the keyword "reduce" rather than "fold"!
[Answer]
# [><>, VTCAKAVSMoACE, ≤ 64](https://codegolf.stackexchange.com/a/60365/21487)
```
'9?':?!;1-$:'@'+o'3'*'='%$30.
```
Ironically, not only is this much lower the range limit, it's also portable and works with the [online interpreter](http://fishlanguage.com/playground).
### Analysis
Let's start with the target string:
```
yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh[
```
><> pushes chars to the stack with `'` or `"` in string mode, but with 63 chars to print and only 64 bytes to work with, the presence of capital letters (invalid instructions in ><>, for the standard looparound trick) make direct printing impossible. Hence, we must be doing something with the code points.
Converting to code points gives (I'm using Python here):
```
>>> L = [ord(c) for c in "yh[cPWNkz^EKLBiQMuSvI`n\Yw|JVXDUbZmfoRC_xrq{TlpHjGt]OadFAsgeyh["]
>>> L
[121, 104, 91, 99, 80, 87, 78, 107, 122, 94, 69, 75, 76, 66, 105, 81, 77, 117, 83, 118, 73, 96, 110, 92, 89, 119, 124, 74, 86, 88, 68, 85, 98, 90, 109, 102, 111, 82, 67, 95, 120, 114, 113, 123, 84, 108, 112, 72, 106, 71, 116, 93, 79, 97, 100, 70, 65, 115, 103, 101, 121, 104, 91]
```
Note that the last three numbers are the same as the first three. This hints at a possible modulo loop going on.
Let's take a look at how many different elements we have:
```
>>> len(set(L))
60
```
We have 63 elements in `L`, the first three of which coincide with the last three. This means that, aside from this collision, all other elements are unique. Now this hints at something like taking powers modulo a prime number. Indeed, `60 + 1 = 61` is prime, which is a good sign.
Let's try finding the smallest element
```
>>> min(L)
65
```
and use that to scale all the elements down so that the min element is 1:
```
>>> M = [x-64 for x in L]
>>> M
[57, 40, 27, 35, 16, 23, 14, 43, 58, 30, 5, 11, 12, 2, 41, 17, 13, 53, 19, 54, 9, 32, 46, 28, 25, 55, 60, 10, 22, 24, 4, 21, 34, 26, 45, 38, 47, 18, 3, 31, 56, 50, 49, 59, 20, 44, 48, 8, 42, 7, 52, 29, 15, 33, 36, 6, 1, 51, 39, 37, 57, 40, 27]
```
Note how the element after `1` is `51`. If there's some sort of powers/multiplication thing going on, this is a good guess for our multiplier.
Let's give it a shot:
```
>>> (57*51)%61
40
>>> (40*51)%61
27
>>> all((x*51)%61 == y for x,y in zip(M, M[1:]))
True
```
Bingo! We can now backtrack, giving the following code:
```
x = 57
for _ in range(63):
    print(chr(x + 64), end="")
    x = (x*51)%61
```
which was then translated to ><>
[Answer]
# [Mathematica, alphalpha, ≤ 32](https://codegolf.stackexchange.com/a/60577/21487)
```
GroupOrder[MonsterGroupM[]]
```
I hate to say this, but I just recognised the number on the spot.
[Answer]
# [Pyth, Maltysen, ≤4](https://codegolf.stackexchange.com/a/60405/21487)
```
C.ZG
```
Brute force took so long that I did it faster manually.
### Analysis
`C` (convert string to base 256 int) is the easiest way to generate a large number in Pyth, so it's probably the first character. If we convert from base 256, we get:
```
xÚKLJNIMKÏÈÌÊÎÉÍË/(,*.)-+¯¨¬ 
```
Hmm... not very illuminating.
Now `G` is the alphabet string `"abc...z"`, which looks like it could be a source for a long string to feed into `C`. Looking through the docs I find:
```
.Z    Compresses or decompresses a string.
```
If we're dealing with compression here, it wouldn't be surprising to get all sorts of extended ASCII characters. Trying `C.ZG` then gave the answer.
[Answer]
# [Fourier, Beta Decay, ≤ 32](https://codegolf.stackexchange.com/a/60347/21487)
```
2~x1~y20(xoy~z*x~yz~xq^~q)
```
Or alternatively, in CJam:
```
X0I{_2$+}*]2\f#
```
### Analysis
At the start we can see a lot of powers of 2:
```
2
1
2
2
4
8
32
256
8192
2097152
...
```
If we take the log base 2 of these numbers, we get:
```
1 0 1 1 2 3 5 8 13 21 ...
```
which is the Fibonacci series, starting at `1, 0`.
[Answer]
## [Snails, feersum, ≤2 bytes](https://codegolf.stackexchange.com/a/60474)
```
z
```
This is actually 2 bytes; the character `z` followed by a newline `\n`.
I have no idea how it works or what it's doing, but after testing all possible inputs apart from `~+` and `~,`, this was the only 2-byte program that produced `8` as output.
And it took *ages* to get this result. No wonder it's called "Snails" :-D
---
*Note to self: The next time you fuzz test unknown software, do it inside a VM.*
[Answer]
## [Rust, Liam Noronha, ≤128 bytes](https://codegolf.stackexchange.com/a/60359/3808)
```
fn main(){print!("AACAAEGAAACIIMOAAACAAEGQQQSYYDFAAACAAEGAAACIIMOHHHJHHLNXXXAGGKMAAACAAEGAAACIIMOAAACAAEGQQQSYYDFOOO");}
```
Simply printing the string verbatim is 120 bytes...
[Answer]
# [Macaroni 0.0.2, Doorknob, ≤64](https://codegolf.stackexchange.com/a/60378/32353)
```
set x "................................."print x print x print x
```
[Answer]
# [Python 2, Clear question with examples, <=64](https://codegolf.stackexchange.com/a/60489/11006)
One possible solution:
```
print ''.join([" `{.~{{~||"[int(c)] for c in str(3**4278)])
```
(`9**2139`, `27**1426` and `729**713` also give the same result)
[Answer]
# [CoffeeScript, user2428118, ≤64](https://codegolf.stackexchange.com/a/60819/32353)
```
alert 0+(btoa k.substr -2 for k of document.body.style).join ''
```
(works only on Chrome 46.0.2490.71 as described by the Cop.)
---
The output is obviously a concatenation of short base64-encoded strings due to all the "=". After decoding them, we find a list of 2-character strings like
```
['nt', 'ms', 'lf', 'ne', 'll', 'on', 'ay', 'on', …
```
which does not seem to make sense. But I find some odd items in it, like `nX` and `tY`. After filtering these out we get
```
>>> # Python
>>>
>>> [i for i in tt if not re.match('[a-z]{2}$', i)]
['nX', 'nY', 'tX', 'tY', 'wX', 'wY', 'r', 'nX', 'nY', 'tX', 'tY', 'nX', 'nY', 'nX', 'nY', 'nZ', 'x', 'y']
```
These X and Y seem to indicate the original source code used position properties like `offsetX/Y`. A particularly interesting is the `nZ` item. To check my assumption, I searched for all properties that end with "Z":
```
// CoffeeScript
checked = []
f = (o) ->
    if !(o in checked) 
        for k of o
            if /Z$/.test(k)
                console.log(o, k)
            if o[k] instanceof Object
                f o[k]
f window
```
which shows tons of `CSSStyleDeclaration, "webkitTransformOriginZ"`. From this we have a strong indication that the list is built up by the last 2 characters of all the keys of a `style` object, which the test above shows indeed is correct.
[Answer]
# [Python 2, histocrat, ≤16](https://codegolf.stackexchange.com/a/60786/32353)
```
[[[51002**3/6]]] 
```
---
The biggest hint is the promise that it won't work in Python 3. [What's changed in Python 3](https://docs.python.org/3.0/whatsnew/3.0.html#integers)? The biggest suspect is that the division operator returns a `float` in Python 3.
So I assume the solution is of the form ⌊αβ/n⌋ = c = 22111101102001, as exponentiation is the only short way to create huge numbers.
If {α, β, n} indeed forms a solution, then (cn)1/β ≈ α should be very close to an integer. Therefore I use the following to try to brute-force the {α, β} for each n:
```
(* Mathematica *)
n=2; Sort[Table[{N[Abs[k - Round@k] /. k -> (22111101102001*n)^(1/b), 12], b}, {b, 2, 50}]]
(* Output: {{0.00262542213622, 7}, ...}
   The first number is the "quality" of the solution, lower is better.
   the second number is β.
   Thus α ≈ (nc)^(1/β) = 89
   But (89^7)/2 = 22115667447764, which is still far away from the answer.
*)
```
The actual result quickly comes out when n = 6.
[Answer]
# [MATLAB, StewieGriffin, ≤ 16](https://codegolf.stackexchange.com/a/60425/42295)
```
[36;87]*' |'*5
```
Prints:
```
ans =
        5760       22320
       13920       53940
```
[Answer]
## [Matlab, Luis Mendo, ≤16](https://codegolf.stackexchange.com/a/60417)
I found it, yay!
```
fix(peaks(9).^2)
```
I didn't know that Octave can do this, too.
[Answer]
# [Mathematica, LegionMammal978, ≤64](https://codegolf.stackexchange.com/a/60385/9288)
```
Print@Nest[Compress,ExampleData[{"Text","ToBeOrNotToBe"}],13]
```
[Answer]
# [Python, spacemanjosh, ≤ 64](https://codegolf.stackexchange.com/a/60659/21487)
```
n=0;d=1;L=[]
exec("L+=[10/(100-n)**.5];n+=d;d+=2;"*10)
print(L)
```
Glorious inverse symbolic calculator. Not well golfed, but hey it fits.
**Edit:** I golfed it.
```
print([10/(100-n*n)**.5for n in range(10)])
```
[Answer]
# [JavaScript ES6, Cᴏɴᴏʀ O'Bʀɪᴇɴ, ≤128 bytes](https://codegolf.stackexchange.com/a/60428/32628)
```
var x=122,s='0037122342526683102122';for(var i=23;i<=505;i+=2)s+=(x+=i);s;
```
I doubt this is exactly right since I didn't need anywhere near 128 bytes, but finding a repeating sequence was fun challenge.
[Answer]
# [Thue, ppperry, <=64](https://codegolf.stackexchange.com/a/60704/6828_)
```
0::=11
1::=22
2::=33
3::=44
4::=55
a::=bbb
b::=000
::=
aaaaaaa
```
Decomposes 2016 into its prime factors, essentially. 62 characters, so my guess is this is similar to what you were going for.
[Answer]
# [Python, DLosc, ≤32](https://codegolf.stackexchange.com/a/60603/7313)
(This solution uses Python 2)
```
a=97
while a<4e31:a^=a*2;print a
```
[Answer]
# [><>, Sp3000, <=8](https://codegolf.stackexchange.com/a/60446/7311)
```
'l(?; o>
```
The instruction pointer wraps around and the following steps happen:
* `'l(?; o>'` pushes the ASCII values of `l(?; o>` to the stack
* `l` pushes the size of the stack on the stack
* `(` compare the top two stack elements: `size of stack` and `ord('>')`
* `?;` stops the program if the stack size was bigger
* `o` output the top element of the stack as character (this will be always `o`)
* `>` sets IP direction, here it is no-op
* we go back to the first step
Output is `oooooooooooo`.
We can get a lot of different outputs by changing `[space]` to something which pushes or pops on the stack and using another valid character instead of `>`, which may also push or pop.
[Answer]
# [JavaScript, ev3commander, ≤ 32](https://codegolf.stackexchange.com/a/61036)
```
console.log(0.1411200080598672)
```
OK, that was easy.
[Answer]
# [CJam, Reto Koradi, ≤ 4](https://codegolf.stackexchange.com/a/60867)
```
HJK#
```
Pushes **17**, then **1920 = 37589973457545958193355601**.
[Try it online.](http://cjam.aditsu.net/#code=HJK%23)
There are only so many things you can do in four bytes. An integer this big had to involve powers or factorials somehow, and a factorial would have trailing zeroes.
[Answer]
# [Lua <= 4, Egor Skriptunoff](https://codegolf.stackexchange.com/a/60514/30688)
A lot of users were getting agitated about this answer in chat, so I must relieve them from their misery. I don't know Lua and wasn't able to test it, but I would be very surprised if this doesn't work.
```
4^~9
```
This would be pretty obvious, but probably no one got it because bitwise operators were only added in version 5.3; ideone.com only has version 5.2.
[Answer]
# [Pyth <= 4, Dennis](https://codegolf.stackexchange.com/a/61047/20080)
```
ljyG
```
That's length of join on newlines of all subsets of the alphabet.
Test run:
```
$ pyth -cd 'ljyG'
==================== 4 chars =====================
ljyG
==================================================
imp_print(Plen(join(subsets(G))))
==================================================
939524095
```
I figured out the number was `2^27 * 7 - 1` which is a strong hint that it's based on `yG`, which is `2^26` elements long. I then guessed it had to be converted to a string and its length printed. However, the only way of doing this I could think of for a while was ``, repr. Then I thought of `j`, which fits perfectly.
[Answer]
# [C, tucuxi, ≤64](https://codegolf.stackexchange.com/a/60528/32353)
```
main(i){for(i=0;i<11000;++i)if(!(i&2*i))printf("1%d",!(i&1));}
```
---
The output are all 0 and 1, but C cannot print binary directly, so it's very likely these are boolean results. 
There are more 1 than 0s, so I recorded the positions of 0s (`3, 9, 13, 19, …`), which turns out to be OEIS [A075318](http://oeis.org/A075318). This is not useful though, there isn't a simple formula to determine where a number is in this sequence.
But we note that there are all odd numbers, so perhaps `(x-1)/2 = {1, 4, 6, 9, 12, …}` have more useful information. And this is [A003622](http://oeis.org/A003622).
A003622 can be defined as "positions of 1's in [A003849](http://oeis.org/A003849)", which is exactly what we need to crack here. And A003849 is defined as "[A003714](http://oeis.org/A003714) mod 2", where A003714 are simply all integers that `x & (2*x) == 0`. Thus we have got the solution.
OEIS rox.
[Answer]
# [Dyalog APL, Dennis, ≤4](https://codegolf.stackexchange.com/a/61048/3852)
```
*⍨⍟8
```
Computes ln(8)^ln(8). Would StackExchange stop converting my answers? I'll type a bunch of stuff here so it doesn't get turned into a comment.
[Answer]
# [Pyth, xnor, ≤ 4](https://codegolf.stackexchange.com/a/60350/21487)
```
C`CG
```
`CG` (convert the alphabet string `"abc...z"` from base 256) is the typical Pyth way of generating a really large number. After that it's just stringify and convert from base again.
[Answer]
# [Ruby, Doorknob, ≤64](https://codegolf.stackexchange.com/a/60391/32353)
```
'@@'=~/(.)(.)/
p$~
test 0 rescue p"#$!@@".gsub //,$!.inspect+$/
```
[Answer]
# [Matlab/Octave, Wauzl, ≤16](https://codegolf.stackexchange.com/a/60491/32353)
```
"234"'*"567"
```
Using the same idea as [Tom Carpenter's answer](https://codegolf.stackexchange.com/a/60436/32353)
(If it did not work, try this:)
```
[50;51;52]*'567'
```
[Answer]
# [CoffeeScript, J Atkin, ≤ 16](https://codegolf.stackexchange.com/a/60570/21487)
```
Math.PI*Math.LN2
```
Hooray for the inverse symbolic calculator.
[Answer]
# [PARI/GP, alephalpha, ≤ 4](https://codegolf.stackexchange.com/a/60344)
```
9!-9
```
I don't actually know the language, but that *has to* be the right answer.
]