[Question]
  [
*easy mode of [my previous challenge](https://codegolf.stackexchange.com/q/251270/78410)*
A perfect number is a positive integer whose sum of divisors (except itself) is equal to itself. E.g. 6 (1 + 2 + 3 = 6) and 28 (1 + 2 + 4 + 7 + 14 = 28) are perfect.
A **sublime number** (OEIS [A081357](http://oeis.org/A081357)) is a positive integer whose count and sum of divisors (including itself) are both perfect. E.g. 12 is a sublime number because:
* the divisors of 12 are 1, 2, 3, 4, 6, 12
* the count of divisors is 6 (perfect)
* the sum of divisors is 28 (perfect)
The next smallest known sublime number is
```
6086555670238378989670371734243169622657830773351885970528324860512791691264
```
which is a product of a power of 2 and six Mersenne primes
$$
2^{126}(2^3-1)(2^5-1)(2^7-1)(2^{19}-1)(2^{31}-1)(2^{61}-1)
$$
These two numbers are the only known sublime numbers as of 2022. The necessary and sufficient conditions for even sublime numbers have been found [in this paper (pdf)](https://web.archive.org/web/20200714113410/http://mathematicstoday.org/archives/V32_2016_5.pdf), but it remains unknown whether odd sublime numbers exist.
It is known that there are no other *even* sublime numbers before the number, but it is not known whether there are any *odd* ones.
## Task
Output the second even sublime number shown above. It is OK to only theoretically output this number in the following ways:
* the program outputs the correct number with probability 1 in finite time
* the program outputs the correct number given enough time and unlimited memory
* the program would output the correct number if the native number type had infinite precision
Standard [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") rules apply. The shortest code in bytes wins.
  
[Answer]
# [PARI/GP](https://pari.math.u-bordeaux.fr), 45 bytes
```
print(vecprod([4^i-2^i|i<-[3,5,7,19,31,61]]))
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m728ILEoMz69YMGCpaUlaboWN3ULijLzSjTKUpMLivJTNKJN4jJ1jeIyazJtdKONdUx1zHUMLXWMDXXMDGNjNTUhmqB6YWYAAA)
The number is \$\prod\_{i\in\{3,5,7,19,31,61\}}(4^i-2^i)\$. In fact, \$126=3+5+7+19+31+61\$.
Another interesting fact is that \$2^{126}\$ is just the sum of divisors of \$\prod\_{i\in\{3,5,7,19,31,61\}}(2^i-1)\$. This might be useful for some golfing language if there is a built-in for divisor sum.
[Answer]
# [Python 2](https://docs.python.org/2/), 37 bytes
```
print~-2**31*~-2**61*14448825433<<126
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v6AoM6@kTtdIS8vYUAtMmxlqGZqYmFhYGJmaGBvb2Bgamf3/DwA "Python 2 – Try It Online")
Writes out \$2^{31}-1\$, \$2^{61}-1\$, and the bit-shift \$2^{126}\$, and hardcodes the remaining product.
[Answer]
# [R](https://www.r-project.org/), ~~33~~ 32 bytes
*Edit -1 byte thanks to [@xnor](https://codegolf.stackexchange.com/users/20260/xnor).*
```
prod(8^42,2^c(3,5,7,19,31,61)-1)
```
[Try it online!](https://tio.run/##bY07DsMgEER7nwKJwiAtBdj5kMRdzoGECJFXclgEvj9BbpNimtG8eaVR3pFSFTVgjmmx1sqWC73E1c0GjAtighNcQFuYNJy1VFo2zjKVndGb@S3m1W89Y2U@d9KH9Tbg8sPdj9fZoTIOJeMfTHE4OnyoPx7AbmL8SX2IYaztCw "R – Try It Online")
Spells out the product.
[@alephalpha's approach](https://codegolf.stackexchange.com/a/251355/55372) lead to +1 byte for me, but [@Dominic van Essen](https://codegolf.stackexchange.com/users/95126/dominic-van-essen) found a 32-byte version (see the footer of the TIO link above).
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~13~~ 11 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
•w4н•foD<*P
```
-2 bytes thanks to *@alephalpha*.
[Try it online.](https://tio.run/##Dcq9DcIwEEDhVayUyEj2ne/HUsoMwAA0Jg4iBRjFBS2zZA92YAYWMa7eV7xS02VdGjtlImJxgIqiUWM3ihcMENBzZAAmUXQiiORVKYojUISg7MiDxH554GDNcEtbPs4lL9maVM1c7s@0rbU8hnP7vfdX@H56rmUaD6dm2x8)
**Explanation:**
```
•w4н•        # Push compressed integer 3772545
     f       # Get its prime factors: [3,5,7,19,31,61]
      o      # Get 2 to the power for each of these integers
       D     # Duplicate the list
        <    # Decrease each by 1 in the copy
         *   # Multiply the values at the same positions in the two lists
          P  # Get the product of this list
             # (after which the result is output implicitly)
```
[See this 05AB1E tips of mine (section *How to compress large integers?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `•w4н•` is `3772545`.
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), ~~20~~ ~~19~~ ~~16~~ 15 bytes
```
*FsmtB^2dPC"9
```
[Try it online!](https://tio.run/##K6gsyfj/X8utOLfEKc4oJcBZyfLQhEON//8DAA "Pyth – Try It Online")
```
*FsmtB^2dPC"9
          C"9  # compressed 3772545
         P     # prime factors (3, 5, 7, 19, 31, 61)
   mtB^2d      # map d: [2**d, 2**d - 1]
  s            # flatten
*F             # reduce on multiplication
```
-3 bytes thanks to @CursorCoercer  
-1 byte thanks to @isaacg
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~14~~ ~~13~~ 11 bytes
```
»;⟑L»ǐE:‹*Π
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLCuzvin5FMwrvHkEU64oC5Ks6gIiwiIiwiIl0=)
-1 byte thanks to alephalpha and -2 bytes thanks to Mukundan314.
# [Jelly](https://github.com/DennisMitchell/jelly), ~~17~~ 16 bytes
```
“¤¦¬Œþ=‘2*’æ«21P
```
[Try it online!](https://tio.run/##ASYA2f9qZWxsef//4oCcwqTCpsKsxZLDvj3igJgyKuKAmcOmwqsyMVD//w "Jelly – Try It Online")
-1 byte thanks to xnor.
[Answer]
# [Factor](https://factorcode.org/) + `math.unicode`, ~~40~~  38 bytes
```
4 2 [ "=">array n^v ] bi@ v- Π .
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQWFSUWFmskJ1alJeao5CbWJKhV5qXmZyfkgrhlKWCVBcrFBSllpRUFhRl5pUoWP83UTBSiFZQYmZlF5a3VbIDG6KQF1emEKuQlOmgUKarcG6Bgt7//wA "Factor – Try It Online")
-2 bytes from porting @alephalpha's [PARI/GP answer](https://codegolf.stackexchange.com/a/251355/97916).
Note `"="` is a literal string that is equivalent to `{ 3 5 7 19 31 61 }`. You can only see the `=` since the rest are non-printable, but you can see the non-printable characters on TIO. This needs to be converted to an array because `n^v` is buggy otherwise. Still 4 bytes shorter than the sequence literal.
* `4 2 [ ... ] bi@` Apply `[ ... ]` to both 4 and 2.
* `{ 3 5 7 19 31 61 } n^v` Input raised to 3, input raised to 5, etc.
* `v-` Subtract two vectors.
* `Π` Take the product.
* `.` Print the result to stdout.
[Answer]
# Bash, 47 Bytes
```
echo "14448825433*(2^31-1)*(2^61-1)*(2^126)"|bc
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I19BydDExMTCwsjUxNhYS8MozthQ11ATxDCDMQyNzDSVapKS//8HAA "Bash – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 32 bytes
```
8^42##&@@(2^{3,5,7,19,31,61}-1)&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b73yLOxEhZWc3BQcMortpYx1THXMfQUsfYUMfMsFbXUFPtf0BRZl5JdFp0bOx/AA "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Prolog (SWI)](http://www.swi-prolog.org), 51 bytes
*Thanks JoKing and Steffan for helping me golf some bytes*
```
?-X is(2^61-1)*14448825433*(2^31-1)*2^126,write(X).
```
[Try it online!](https://tio.run/##KyjKz8lP1y0uz/z/3143QiGzWMMozsxQ11BTy9DExMTCwsjUxNhYCyhoDBY0ijM0MtMpL8osSdWI0NT7/x8A "Prolog (SWI) – Try It Online")
My very first Prolog answer :D, probably can be golfed a lot though.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 21 bytes
```
ＩΠＥＸ²⁻Ｅ357COm℅ι⁴⁸×ι⊖ι
```
[Try it online!](https://tio.run/##HYm7CsMwDAB/xWRSwFmalhY6pmuIh/6AsAUV@BFkJ/l8tekNN9z5D4ovGFWdcG4wYW3gpITNN5hxBVcOErhYM3Pe6j914@0@LamzZpHAGSNw31tzfZx@c6IKbM2LvFCi3Cic/8dTVYc9fgE "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
       357COm           Literal string `357COm`
      Ｅ                 Map over characters
              ι         Current character
             ℅          ASCII code
     ⁻                  Vectorised subtract
               ⁴⁸       Literal integer `48`
   Ｘ                    Vectorised exponentiate with base
    ²                   Literal integer `2`
  Ｅ                     Map over powers of `2`
                    ι   Current power of `2`
                   ⊖    Decremented
                 ×      Multiplied by
                  ι     Current power of `2`
 Π                      Take the product
Ｉ                       Cast to string
                        Implicitly print
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/math_golf.txt), 15 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
357HT╟)]ó_(m*ε*
```
[Try it online.](https://tio.run/##y00syUjPz0n7/9/Y1Nwj5NHU@ZqxhzfHa@Rqnduq9f8/AA)
**Explanation:**
```
3        # Push 3
 5       # Push 5
  7      # Push 7
   H     # Push 19
    T    # Push 31
     ╟   # Push 60
      )  # Increase the 60 by 1
       ] # Wrap the stack into a list: [3,5,7,19,31,61]
ó        # Calculate 2 to the power each of these integers
 _       # Duplicate the list
  (      # Decrease each by 1
   m*    # Multiply the values at the same positions in the lists together
     ε*  # Product: reduce by multiplication
         # (after which the entire stack joined together is output implicitly as result)
```
[Answer]
# [MATL](https://github.com/lmendo/MATL), ~~21~~ ~~19~~ ~~18~~ 14 bytes
```
3772545YfWtqhp
```
[Try it online!](https://tio.run/##y00syfn/39jc3MjUxDQyLbykMKPg/38A "MATL – Try It Online")
```
3772545YfWtqhp
3772545Yf         # Prime factorize 3772545 (3, 5, 7, 19, 31, 61)
         W        # 2 ** elements
          t       # duplicate list
           q      # decrement elements in copy by 1
            h     # concatenate lists 
             p    # product
```
-2 bytes thanks to @Luis Mendo
[Answer]
# [Nibbles](http://golfscript.com/nibbles/index.html), ~~16 15~~ 12.5 bytes
```
`*.`D62*;^2$-$~ a8532dc3
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m708LzMpKSe1eMGCpaUlaboWOxK09BJczIy0rOOMVHRV6hQSLUyNjVKSjSHSUFUw1QA)
*-2.5 bytes thanks to Dominic van Essen*
Nibbles has no prime-related built-ins, so I had to resort to good old base conversion.
```
`*.`D62*;^2$-$~ a8532dc3
`*                       Product
  .                       for each n in
   `D62                    convert from base 62
                a8532dc3    2824023491
       *                   multiply
         ^2                 2 to the power of
           $                 n
        ;    $              with itself
            - ~              minus 1
```
[Answer]
# [Burlesque](https://github.com/FMNSSun/Burlesque), 33 bytes
```
{Jfc~]++==}s1r1f{fcsa%1!j++%1!&&}
```
[Try it online!](https://tio.run/##SyotykktLixN/f@/2istuS5WW9vWtrbYsMgwrTotuThR1VAxS1sbSKqp1f7/DwA "Burlesque – Try It Online")
Given infinite time, should find sublime numbers
```
{    # IsPerfect function
 J   # Duplicate
 fc  # Factors
 ~]  # Without self
 ++  # Sum
 ==  # Equals self
}s1  # Store as "1"
r1   # Range 1..inf
f{   # Filter
 fc  # Factors
 sa  # Non-destructive Length
 %1! # IsPerfect
 j++ # Sum of factors
 %1! # IsPerfect
 &&  # And
}
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), ~~16~~ 13 bytes
```
₆¨*≬K₍L∑¨=∆Kc
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCLigobCqCriiaxL4oKNTOKIkcKoPeKIhktjIiwiIiwiIl0=)
half-Legitimate calculation ~~is~~ was shorter than hard coding lol. Given enough time and memory, this would eventually output the right number.
## Explained
```
₆¨*≬K₍L∑¨=∆Kc
₆¨*≬        c   # From all multiples of 64 (which contains the target number), get the first where:
    K₍L∑        #   The list [len(factors), sum(factors)]
        ¨=∆K    #   Is invariant under sum of proper divisors
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 12 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
⁹Æs;ÆdÆṣƑƲ1#
```
A full program that will (eventually!) print the result.
[Don't Try it online!](https://tio.run/##AR4A4f9qZWxsef//4oG5w4ZzO8OGZMOG4bmjxpHGsjEj//8 "Jelly – Try It Online")  
The `⁹` starts the search at 256, if one replaces it with `1` it'll find `12` - try that **[here](https://tio.run/##y0rNyan8/9/wcFux9eG2lMNtD3cuPjbx2CZD5f//AQ "Jelly – Try It Online")**.
---
Faster in 13:
```
“;Y,’Æf2*×’$P
```
Try it [here](https://tio.run/##y0rNyan8//9RwxzrSJ1HDTMPt6UZaR2eDmSpBPz/DwA "Jelly – Try It Online").
[Answer]
# Python, ~~49 46~~ 45 bytes
Did some google calculation.
```
print(2**126*14448825433*(2**31-1)*(2**61-1))
```
[Answer]
# [Thunno](https://github.com/Thunno/Thunno), \$ 17 \log\_{256}(96) \approx \$ 13.99 bytes
```
3772545AF2@D1-z*P
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72sJKM0Ly9_wYKlpSVpuhYbjc3NjUxNTB3djBxcDHWrtAIg4lBpmDIA)
Port of [Kevin Cruijssen's 05AB1E answer](https://codegolf.stackexchange.com/a/251370/114446).
```
3772545AF2@D1-z*P
3772545            # Push 3772545                (there's no integer compression in Thunno)
       AF          # Prime factors of that       ([3, 5, 7, 19, 31, 61])
         2@        # 2 ** each one               ([8, 32, 128, 524288, 2147483648, 2305843009213693952])
           D1-     # Duplicate and subtract one  ([7, 31, 127, 524287, 2147483647, 2305843009213693951])
              z*   # Multiply                    ([56, 992, 16256, 274877382656, 4611686016279904256, 5316911983139663489309385231907684352]) 
                P  # Product of the list         (6086555670238378989670371734243169622657830773351885970528324860512791691264)
```
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), ~~22~~ ~~17~~ 16 bytes
```
3772545ǰϼ2⇹^Đ⁻*Π
```
[Try it online!](https://tio.run/##AR8A4P9weXT//zM3NzI1NDXHsM@8MuKHuV7EkOKBuyrOoP// "Pyt – Try It Online")
```
3772545             push 3, 7, 7, 2, 5, 4, 5
       ǰ            ǰoin elements on stack with no delimiter 
         ϼ          get unique ϼrime factors (casts to integer)
          2⇹^       raise 2 to each power
             Đ⁻     Đuplicate; decrement
               *    element-wise multiplication
                Π   product of list; implicit print
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jellylanguage), 30 bytes
My first Jelly answer! Hope I'll get better in the future.
```
2*’
[3,5,7,19,31,61]ç
¢×/æ«126
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m700KzUnp3LBgqWlJWm6FjdVjbQeNczkijbWMdUx1zG01DE21DEzjD28nOvQosPT9Q8vO7Ta0MhsSXFScjFUy6LoWCgLAA)
[Answer]
# [J](https://www.jsoftware.com), 23 bytes
```
echo*/(,<:)2^q:3772545x
```
Same solution as most answers.
[Attempt This Online!](https://ato.pxeger.com/run?1=m70wa8GCpaUlaboW21OTM_K19DV0bKw0jeIKrYzNzY1MTUwrILJQRTDFAA)
```
echo*/(,<:)2^q:3772545x
               3772545x  NB. extended precision literal
             q:          NB. prime factors
           2^            NB. raise 2 to each factor
      (,<:)              NB. monadic hook 
        <:               NB. decrement
       ,                 NB. concat with hook input
    */                   NB. product reduce
echo                     NB. print
```
]