JavaScript (Node.js), 62 bytes

console.log(8n**42n*14448825433n*(2n**31n-1n)*(2n**61n-1n)+'')

Try it online!

port of similar solutions to JavaScript

J, 23 bytes

echo*/(,<:)2^q:3772545x

Same solution as most answers.

Attempt This Online!

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

R, 33 32 bytes

Edit -1 byte thanks to @xnor.

prod(8^42,2^c(3,5,7,19,31,61)-1)

Try it online!

Spells out the product.

@alephalpha's approach lead to +1 byte for me, but @Dominic van Essen found a 32-byte version (see the footer of the TIO link above).

Jelly, 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!

Nibbles, 16 15 12.5 bytes

`*.`D62*;^2$-$~ a8532dc3

Attempt This Online!

-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

Pyt, 22 17 16 bytes

3772545ǰϼ2⇹^Đ⁻*Π

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

Thunno, \$ 17 \log_{256}(96) \approx \$ 13.99 bytes

3772545AF2@D1-z*P

Attempt This Online!

Port of Kevin Cruijssen's 05AB1E answer.

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)

Python, 49 46 45 bytes

Did some google calculation.

print(2**126*14448825433*(2**31-1)*(2**61-1))

Prolog (SWI), 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!

My very first Prolog answer :D, probably can be golfed a lot though.

MATL, ^{21 19 18} 14 bytes

3772545YfWtqhp

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

Pyth, ^{20 19 16} 15 bytes

*FsmtB^2dPC"9

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

Wolfram Language (Mathematica), 32 bytes

8^42##&@@(2^{3,5,7,19,31,61}-1)&

Try it online!

Jelly, 12 bytes

⁹Æs;ÆdÆṣƑƲ1#

A full program that will (eventually!) print the result.

Don't Try it online!
The ⁹ starts the search at 256, if one replaces it with 1 it'll find 12 - try that here.

Faster in 13:

“;Y,’Æf2*×’$P

Try it here.

Vyxal, 16 13 bytes

₆¨*≬K₍L∑¨=∆Kc

Try it Online!

^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

Bash, 47 Bytes

echo "14448825433*(2^31-1)*(2^61-1)*(2^126)"|bc

Try it online!

MathGolf, 15 bytes

357HT╟)]ó_(m*ε*

Try it online.

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)

Burlesque, 33 bytes

{Jfc~]++==}s1r1f{fcsa%1!j++%1!&&}

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
}

05AB1E, 13 11 bytes

•w4н•foD<*P

-2 bytes thanks to @alephalpha.

Try it online.

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?) to understand why •w4н• is 3772545.

Charcoal, 21 bytes

ＩΠＥＸ²⁻Ｅ357COm℅ι⁴⁸×ι⊖ι

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

Factor + math.unicode,  ⁴⁰ 38 bytes

4 2 [ "=">array n^v ] bi@ v- Π .

Try it online!

-2 bytes from porting @alephalpha's PARI/GP answer.

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.

PARI/GP, 45 bytes

print(vecprod([4^i-2^i|i<-[3,5,7,19,31,61]]))

Attempt This Online!

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.

Vyxal, 14 13 11 bytes

»;⟑L»ǐE:‹*Π

Try it Online!

-1 byte thanks to alephalpha and -2 bytes thanks to Mukundan314.

Jelly, 17 16 bytes

“¤¦¬Œþ=‘2*’æ«21P

Try it online!

-1 byte thanks to xnor.

Python 2, 37 bytes

print~-2**31*~-2**61*14448825433<<126

Try it online!

Writes out \$2^{31}-1\$, \$2^{61}-1\$, and the bit-shift \$2^{126}\$, and hardcodes the remaining product.