[Question]
  [
[Laguerre polynomials](https://en.wikipedia.org/wiki/Laguerre_polynomials) are nontrivial solutions to Laguerre's equation, a second-order linear differential equation: \$xy''+(1-x)y'+ny=0\$. For a given value of \$n\$, the solution, \$y\$, is named \$L\_n(x)\$. To avoid trivial solutions, the polynomials are non-constant except for \$n=0\$.
The polynomials can be found without calculus using recursion:
\$L\_0(x)=1\$
\$L\_1(x)=1-x\$
\$L\_{k+1}(x)=\frac{(2k+1-x)L\_k(x)-kL\_{k-1}(x)}{k+1}\$
Summation can be used to the same end:
\$L\_n(x)=\sum\limits\_{k=0}^{n}{n\choose k}\frac{(-1)^k}{k!}x^k\$
\$L\_n(x)=\sum\limits\_{i=0}^n\prod\limits\_{k=1}^i\frac{-(n-k+1)x}{k^2}\$
The first Laguerre polynomials are as follows:
[![polynomials](https://i.stack.imgur.com/LR4kc.png)](https://i.stack.imgur.com/LR4kc.png)
Coefficients can be found [here](https://oeis.org/A021010).
# The Challenge
Given a nonnegative integer \$n\$ and a real number \$x\$, find \$L\_n(x)\$.
# Rules
* This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") so the shortest answer in bytes wins.
* Assume only valid input will be given.
* Error should be under one ten-thousandth (±0.0001) for the test cases.
# Test Cases
Here, \$n\$ is the first number and \$x\$ is the second.
```
In: 1 2
Out: -1
In: 3 1.416
Out: -0.71360922
In: 4 8.6
Out: −7.63726667
In: 6 -2.1
Out: 91.86123261
```
  
[Answer]
# [Python 2](https://docs.python.org/2/), 53 bytes
```
f=lambda n,x:n<1or((2*n-1-x)*f(n-1,x)-~-n*f(n-2,x))/n
```
[Try it online!](https://tio.run/##TchBCoNADEDRvafIciLJ1EQRKe1hFBkUNIq4GDdefSoFaXf//fXYh8U0pfCe2rnrWzCKT3vJsjmnubFwxDy4Kygin2xf6AV8WFq30XYITgjUF5jdLgnEV1L/TkXQ@D/XBKxeMH0A "Python 2 – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 9 bytes
```
LaguerreL
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2773ycxvTS1qCjV539AUWZeiYJDerSZjq6RnmHs//8A "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~11~~ 10 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ŻṚṀc÷!ƲḅN}
```
A dyadic Link accepting \$n\$ on the left and \$x\$ on the right which yields \$L\_n(x)\$.
**[Try it online!](https://tio.run/##ASMA3P9qZWxsef//xbvhuZrhuYBjw7chxrLhuIVOff///zb/LTIuMQ "Jelly – Try It Online")**
### How?
This makes the observation that  
\$L\_n(x)=\sum\limits\_{k=0}^{n}{n\choose k}\frac{(-1)^k}{k!}x^k=\sum\limits\_{k=0}^{n}{(-x)^k}\frac{n\choose k}{k!}\$  
which is the evaluation of a base \$-x\$ number with n+1 digits of the form \$\frac{n\choose k}{k!}\$.
```
ŻṚṀc÷!ƲḅN} - Link: n, x
Ż          - zero-range (n) -> [0, 1, 2, ..., n]
 Ṛ         - reverse -> [n, ..., 2, 1, 0]
      Ʋ    - last four links as a monad - f(I=that):
  Ṁ        -   maximum -> n
   c       -   {that} binomial (I) -> [nCn, ..., nC2, nC1, nC0]
     !     -   {I} factorial -> [n!, ..., 2!, 1!, 0!]
    ÷      -   division -> [nCn÷n!, ..., nC2÷2!, nC0÷0!]
        N} - negate right argument -> -x
       ḅ   - convert from base (-x) -> -xⁿnCn÷n!+...+-x²nC2÷2!+-x¹nC1÷1!+-x°nC0÷0!
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), 5 bytes
```
_1iZh
```
Inputs are \$n\$, then \$x\$. [Try it online!](https://tio.run/##y00syfn/P94wMyrj/39jLkM9E0MzAA) Or [verify all test cases](https://tio.run/##y00syfmf8D/eMDMq479LyH9DLiMuYy5DPRNDMy4TLgs9My4zLl0jPUMA).
### How it works
This uses the [equivalence](https://en.wikipedia.org/wiki/Laguerre_polynomials#Relation_to_hypergeometric_functions) of Laguerre polynomials and the (confluent) hypergeometric function:
\$
L\_n(x) = {} \_1F\_1(-n,1,x)
\$
```
_    % Implicit input: n. Negate
1    % Push 1
i    % Input: x
Zh   % Hypergeometric function. Implicit output
```
[Answer]
# JavaScript (ES6), ~~48 42~~ 41 bytes
Expects `(x)(n)`. May output [**true** instead of **1**](https://codegolf.meta.stackexchange.com/a/9067/58563).
```
x=>g=k=>k<1||((x-k---k)*g(k)+k*g(k-1))/~k
```
[Try it online!](https://tio.run/##ZclLCoNAEEXReVZST6mWUpEM0u5F/DRaYouG4EDcemuG4ujCuUP1q9Z66ecvT75pQ2fDZktn1Zb6kX0n2liZWRE5UsT6DwuQHBpqP61@bM3oHXWUgi5/3VFMLgUoe4y3uTh/MKdGQAUQTg "JavaScript (Node.js) – Try It Online")
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 66 bytes
```
L=lambda n,x:((2*n-1-x)*L(d:=n-1,x)-d*L(n-2,x))/n if n>1else 1-n*x
```
[Try it online!](https://tio.run/##TchBCoMwEEDRfU@R5UyYSZkoIoKeIJewxFLBToN1kZ4@ZlNw999Pv@P10aZPeylh3Ob3I85GKQ8A3ioLZ7QB4jDWpowcq5R9TbyrWZ9GJ1m272KE1eaS9lUPCCDkEW9/NSSule5yWurd1R2xd4JYTg "Python 3.8 (pre-release) – Try It Online")
Direct implementation of the recursive algorithm, with one interesting part: `L(1,x)` and `L(0,x)` can be combined as `L(n,x)=1-n*x`.
Could save 2 bytes using `L=lambda n,x:n>1and((2*n-1-x)*L(d:=n-1,x)-d*L(n-2,x))/n or 1-n*x`, but `L(n)` is not necessarily zero.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 16 [bytes](https://github.com/abrudz/SBCS)
```
1⊥⍨0,⎕×(-÷⌽×⌽)⍳⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97b/ho66lj3pXGOg86pt6eLqG7uHtj3r2Hp4OJDQf9W4GCoKU/edM4zLkMuICUsZchnomhmYgpgmXhR6YYcZ1aL2RniEA "APL (Dyalog Unicode) – Try It Online")
A full program that takes `n` and `x` from two separate lines of stdin.
### How it works
```
1⊥⍨0,⎕×(-÷⌽×⌽)⍳⎕
              ⍳⎕  ⍝ Take n and generate 1..n
       (-÷⌽×⌽)    ⍝ Compute i÷(n+1-i)^2 for i←1..n
   0,⎕×           ⍝ Multiply x to each and prepend 0, call it B
1⊥⍨               ⍝ Convert all ones from base B to single number
```
The mixed base conversion looks like this:
```
1..n:                ... n-3          n-2          n-1          1
B:            0      ... (n-3)x/4^2   (n-2)x/3^2   (n-1)x/2^2   nx
digits:       1      ... 1            1            1            1
digit values: x^n/n! ... (nC3 x^3/3!) (nC2 x^2/2!) (nC1 x^1/1!) (nC0 x^0/0!)
```
It is essentially a fancy way to write the sum of product scan over `1, nx, (n-1)x/2^2, (n-2)x/3^2, ...`. This happens to be shorter than a more straightforward `-x`-base conversion (evaluating a polynomial at `-x`):
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 18 [bytes](https://github.com/abrudz/SBCS)
```
(-⎕)⊥⌽1,(!÷⍨⊢!≢)⍳⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKM97b@G7qO@qZqPupY@6tlrqKOheHj7o94Vj7oWKT7qXKT5qHczUBak8D9nGpchlxEXkDLmMtQzMTQDMU24LPTADDOuQ@uN9AwB "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 61 bytes
```
L=lambda k,x:k<1or[1-x,L(w:=k-1,x)*(k+w-x)-L(k-2,x)*w][k>1]/k
```
[Try it online!](https://tio.run/##HYxBCsIwEADvvmKPiW4im5ZSgvUF@UHpoSJiWZuEUEh8fWy9DQMz8bu9g2/6mGp1w2deH88ZGIvlG4U0kiroRLYDK8Iiz4IvWRWpnGBlDpGnke80Xbm@QtpDKLB4EIRgJIJoEEi31B3cIvT6Tx2CMpqkPQHEtPhN7L89lbL@AA "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 36 bytes
```
x=>(i=0,g=n=>n?1-x*n/++i/i*g(n-1):1)
```
[Try it online!](https://tio.run/##ZclNCoMwEAbQvSeZT5voWBERxp5F/AkRmZQq4u2j2@L2vaU/@m34@e9uNIxTnCWe0pGX4uVEpdMPmzPVPMt87lNHahgtIw5Bt7BOdg2OZipBDCT/yLbiGvR@RGNvrh5sSsugGogX "JavaScript (Node.js) – Try It Online")
Just convert the formula to this, and use recursive:
$$ L\_n(x) = \sum\_{i=0}^n\prod\_{k=1}^i\frac{-(n-k+1)x}{k^2} $$
[Answer]
# [J](http://jsoftware.com/), 37 20 bytes
*-5 thanks to @Bubbler*
Calculates the polynomial adapted from the summation formula and uses J's `p.` operator to calculate that polynomial with a given x.
```
(p.-)~i.((!]/)%!)@,]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/NQr0dDXrMvU0NBRj9TVVFTUddGL/K/g56SlwFejBxbXiDdXiIJJcqJI2Vg7K2KUxJDP1HOysuDT/KwCBkYKGjnWapoIhl6GeiaEZlGfMpaBgoQfjmXApxBvpGUJ5ZgA "J – Try It Online")
# [J](http://jsoftware.com/), 45 byte
Alternative Recursive function.
```
1:`-@.[~ ::((>:@]%~($:*[-~1+2*])-]*($:<:))<:)
```
[Try it online!](https://tio.run/##Nce9CoMwFIbhPVfxIS3mpObgSUXK6Q@C4OTkKkEnh15Ebj3NYF94h@ebK64PvBU1GrTQsmeMyzxl0d0PvCaoWvvRIV6TvahbfZJbcJF8dMUvJSpnyigF2OZ5EMQId9KfuhvgwX91BltgOdX/AA "J – Try It Online")
### How it works
We define a hook `(fg)`, which is `x f (g n)`. `f` is `(p.-)~` so it will be evaluated as `((i.((!]/)%!)@,]) n) p. (- x)`.
```
(p.-)~i.((!]/)%!)@,]
      i.         @,] enumerate 3 -> 0 1 2, append 3 -> 0 1 2 3, …
         (!]/)       3 over i
              %      divided by
               !     !i
   -                 negate x
 p.                  apply -x to the polynomial expressed in J as
                     1 3 1.5 0.166667, so 1-3(-x)+1.5(-x)^2+0.16(-x)^3
```
[Answer]
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 39 bytes
Using the formula \$L\_n(x)=\sum\_{k=0}^n \binom{n}{k}\frac{(-1)^k}{k!} x^k\$.
```
l(n,x)=sum(k=0,n,n!*(-x)^k/(n-k)!/k!^2)
```
[Try it online!](https://tio.run/##HcfBCoMwDADQX0k9JSOpayeyi/6IVAg7DGlXitvAfX2n3t4rui7yLLUmzLzR8P6@MA5XzpzNBWWjObaYJZJpo5k9VS0l/VBBRijrkj87myMNPDQlTAxKxDBNjsGHHTcGZzvXH@4Y7vZUzyDeuhCo/gE "Pari/GP – Try It Online")
---
# [Pari/GP](http://pari.math.u-bordeaux.fr/), 45 bytes
Using the generating function \$\sum\_{n=0}^\infty x^n L\_n(t)= \frac{1}{1-x} e^{-xt/(1-x)}\$.
```
l(n,t)=Vec(exp(-x*t/(1-x)+O(x^n++))/(1-x))[n]
```
[Try it online!](https://tio.run/##JcfBCsIwDADQXwk7JTatZI7hxf3Cbl5KhTKGDEoJo4f69XXT23sa982@tbWEmQs9nuuCa1W09VKuKLaSmbG@sjFE/5PPoUXV9MEIdgLdt1wOdmc6WGJKmBgiEYP3wtCHAzcGcYOMpweGu/tpZLC9kxCofQE "Pari/GP – Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 29 bytes
```
⊞υ¹ＦＮ⊞υ×⌈υＬυＩ↨Ｅυ∕⌈υ×ιＸ§⮌υκ²±Ｎ
```
[Try it online!](https://tio.run/##XY7NDoIwEITvPkWP2wRM4ODFkz8XEiWN8QUqrNBAW9If5O3rEuNBD5s9zHwz0/TSNVaOKYnoe4gZK/h@87SOQWWmGOqoH@iAc/bV70qjh6tclI4aIs/YBU0XSOOcUOGUCXCSPsBReiTjtFJnNasWf7BPkMqYsC@qOITKtLjADWd0BK6Wga6kWHo1djLg36i1MaUdy8ttkfJ5fAM "Charcoal – Try It Online") Link is to verbose version of code. Uses a slightly modified version of the summation given in the question. Explanation:
```
⊞υ¹ＦＮ⊞υ×⌈υＬυ
```
Calculate the factorials from \$0!\$ to \$n!\$.
```
Ｉ↨Ｅυ∕⌈υ×ιＸ§⮌υκ²±Ｎ
```
For each index \$i\$ from \$0\$ to \$n\$ calculate \$\frac{n!}{i!(n-i)!^2}\$ and then perform base conversion from base \$-x\$ which multiplies each term by \$(-1)^{n-i}x^{n-i}\$ and takes the sum.
If we set \$k=n-i\$ we see that we calculate \$\sum\limits\_{k=0}^{n}{\frac{n!(-1)^k}{(n-k)!k!^2}x^k}=\sum\limits\_{k=0}^{n}{n\choose k}\frac{(-1)^k}{k!}x^k\$ as required.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-x`](https://codegolf.meta.stackexchange.com/a/14339/), ~~28~~ ~~27~~ 26 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ò@l *VpX /Xl ²*JpX /(U-X l
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LXg&code=8kBsICpWcFggL1hsILIqSnBYIC8oVS1YIGw&input=NgotMi4x)
# [Japt](https://github.com/ETHproductions/japt), ~~30~~ ~~29~~ 28 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
```
ò x@l *VpX /Xl ²*JpX /(U-X l
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=8iB4QGwgKlZwWCAvWGwgsipKcFggLyhVLVggbA&input=NgotMi4x)
## Explanation
```
ò x@l *VpX /Xl ²*JpX /(U-X l
ò                               // Create a array [0, 1, ..., U]
  x                             // sum the array after mapping through
   @                            // Function(X)
    l                           //    U!
      *VpX                      //    times V ** X
           /Xl ²                //    divided by X! ** 2
                *JpX            //    times (-1) ** X
                     /(U-X l    //    divided by (U - X)!
```
* `U` is the first input
* `V` is the second input
* `**` represents exponentiation
* `!` represents factorial
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 91 bytes
```
i;k;float f(n,x)float x;{float p,s=0;for(i=++n;k=i--;s+=p)for(p=1;--k;)p*=(k-n)*x/k/k;x=s;}
```
[Try it online!](https://tio.run/##dclBCoMwEEDRfU8hQiFjMmqsSGGYm3QjQkpIG4O6CIhnTytudff5b8D3MKRkyZH5jP2SGeFVhKMjrUcENXNNZpyEZSk9ObaINEsOsM/AmhAdQShYOPRQxMpVjiLPtKVvb72A9ZZlYbJ@MSK/m5fPlRG1akoAOhF9KY3SF/L4S6u7c2zVs7ygTmFT6t229AM "C (gcc) – Try It Online")
Straighforward implementation of polynomial expansion. Slightly golfed less
```
i;k;
float f(n,x)float x;{
  float p,s=0;
  for(i=++n;k=i--;s+=p)
    for(p=1;--k;)
      p*=(k-n)*x/k/k;
  x=s;
}
```
[Answer]
## [Fortran (GFortran)](https://gcc.gnu.org/fortran/), ~~69~~ 68 bytes
```
read*,n,a
print*,sum([(product([((j-n-1)*a/j/j,j=1,i)]),i=0,n)])
end
```
*-1 byte thanks to @ceilingcat*
The program reads in an implicit integer n and real a. Summation and product operations are performed using arrays (initialized using implicit loops) with the intrinsics sum() and product().
[Try it online!](https://tio.run/##JcaxCoAgEADQva9oVDkzG9r8kmiQ1FDolEu/34Te9EKmShblHf70Tt46AQh2KhSxCnjbww5WKLt21TGWJErNhVVJJUhGQ@Qnh2hWwJHJo@t9n@W26A8 "Fortran (GFortran) – Try It Online")
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~16~~ 11 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
DÝR©c®!/I(β
```
Port of [*@JonathanAllan*'s Jelly answer](https://codegolf.stackexchange.com/a/207067/52210), so make sure to upvote him as well!
[Try it online](https://tio.run/##yy9OTMpM/f/f5fDcoEMrkw@tU9T31Di36f9/Yy5DPRNDMwA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9Waa@k8KhtkoKSfWVC6H@Xw3ODDq1MPrROUT9C49ym/zr/o6MNdYxidaKNdQz1TAzNgCwTHQs9EG2mo2ukZxgbCwA).
**Original 16 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage) answer:**
```
1λèN·<I-₁*N<₂*-N/
```
[Try it online](https://tio.run/##yy9OTMpM/f/f8Nzuwyv8Dm238dTV8rN51NSkpeun//@/MZehnomhGQA) or [verify all test cases](https://tio.run/##S0oszvifnFiiYKeQnJ@SqpdfnJiUmapgY6Pg6u/GZa@k8KhtkoKSfUxC6H/Dc7sPr/A7tN0mQvdRU6OWn82jpiYtXT/9/7U6XCDFXOUZmTmpCkWpiSkKmXlcKflcCgr6@QUl@hAzoRSaNTYKKmC1ean/ow11jGK5oo11DPVMDM2ALBMdCz0Qbaaja6RnGMsFAA).
**Explanation:**
```
D                 # Duplicate the first (implicit) input-integer `n`
 Ý                # Pop one, and push a list in the range [0,n]
  R               # Reverse it to range [n,0]
   ©              # Store this list in variable `®` (without popping)
    c             # Get the binomial coefficient of `n` and each value in this list
     ®!           # Push list `®` again, and get the factorial of each
       /          # Divide the values at the same positions of the two lists
        I(        # Push the second input `x`, and negate it
          β       # Convert the list from base-(-x) to a single decimal value
                  # (which is output implicitly as result)
```
---
Uses the recursive formula:
$$a(n)=\frac{a(n-1)\times(2n-1-x)-(n-1)\times a(n-2)}{n}$$
```
 λ                # Create a recursive environment
  è               # to get the 0-based n'th value afterwards
                  # (where `n` is the first implicit input)
                  # (which will be output implicitly as result at the end)
1                 # Starting with a(-1)=0 and a(0)=1,
                  # and for every other a(N), we'll:
                  #  (implicitly push a(N-1))
   N·             #  Push `N` doubled
     <            #  Decrease it by 1
      I-          #  Decrease it by the second input `x`
        *         #  Multiply it by the implicit a(N-1)
         N<       #  Push `N`-1
           ₂*     #  Multiply it by a(N-2)
             -    #  Decrease the a(N-1)*(2N-1-x) by this (N-1)*a(N-2)
              N/  #  And divide it by `N`: (a(N-1)*(2N-1-x)-(N-1)*a(N-2))/N
```
[Answer]
# [Scala](https://www.scala-lang.org/), 81 bytes
Use the recursive formula of Laguerre Polynomials.
---
Golfed version. [Try it online!](https://tio.run/##ZYyxDoIwFEV3vuKNfaStFgkxjQwmLg5Oxsk4FCykBouBmmAI345FneQuJ/fc5La5qtRYZzedOzgoY6Efr7qAgli5t452clc/s0rjj2lv/LQRKEBXrSYkCi0TrMPQayZoh2zit0a@4sIOI8D0eff3RDVlK2HbNOp1PrrG2PKCEk7WOEihD8Dn4a2rLCmIoBDxJeKfXlEQPBbJbIgprPlcJxRYxMXHD8EwvgE)
```
def f(n:Int,x:Double):Double={if(n<1)1 else((2*n-1-x)*f(n-1,x)-(n-1)*f(n-2,x))/n}
```
Ungolfed version. [Try it online!](https://tio.run/##ZY5PC4JAFMTvfoo57sq6tSYSUoegS4dO0Sk6rLaKYWvoBkb42W21f5CHB29@b5g3dSIL2XVlfFaJwVbmGg8HOKkUKdERNtowNBHW5S0uFP0sWA42ILcuLCAoxKBVUSsQ4rsaHoSdhsLto3rJeuXhJX7c7znFBNpGtM77/cV2IbLK6girqpL3w85Uuc6OtsNe5@bb4GqpKTRJic33@ZTSPzxjEDwQ4egQMMz5GIcMns/FwFun7bon)
```
object Main {
  def f(n: Int, x: Double): Double = {
    if(n < 1) 1
    else ((2*n - 1 - x) * f(n - 1, x) - (n - 1) * f(n - 2, x)) / n
  }
  def main(args: Array[String]): Unit = {
    println(f(1, 2.0))
    println(f(3, 1.416))
    println(f(4, 8.6))
    println(f(6, -2.1))
  }
}
```
[Answer]
# HTML, 1 Byte, Invalidated by newest edit.
```
0
```
\$y=0\$ is a solution to the equation stated in the question for all \$x\$ and \$n\$.
[Answer]
# Jelly, 0 Bytes, invalidated by newest edit
[Try it online!](https://tio.run/##y0rNyan8DwQA) Note that \$y=0\$ is a solution for all \$x\$ and \$n\$. Port of [my HTML answer](https://codegolf.stackexchange.com/a/261536/117478).
[Thanks to Jonathan Allen for pointing out this port, and also that this might be a polyglot](https://codegolf.stackexchange.com/questions/207034/laguerre-polynomials#comment574720_261536).
]