Теория чисел содержит множество проблем, попытки решения которых предпринимались математиками в течение десятков, а иногда даже сотен лет,
но которые пока так и остаются открытыми. Ниже приведены лишь некоторые из наиболее известных проблем, как решенных, так и нет.
Гипотеза Гольдбаха
В 1742 году математик Кристиан Гольдбах сформулировал гипотезу в письме к Леонарду Эйлеру,
Эта гипотеза существует в 2-х вариантах - бинарном и тернарном.
Бинарный вариант: любое чётное число можно представить в виде суммы двух простых чисел.
Тернарный вариант: любое нечётное число можно представить в виде суммы трёх простых чисел.
Тернарный вариант был доказан в 2013 году.
Бинарная проблема Гольдбаха всё ещё далека от решения.
На апрель 2012 года бинарная гипотеза Гольдбаха была проверена для всех чётных чисел, не превышающих 4×1018.
В основе доказательства тернарного варианта лежат результаты, полученные Харди - Литлвудом - Рамануджаном.
Изучая проблему Варинга, они создали т.н. круговой метод:
решение задачи (например, количество способов представить целое число в виде суммы трех простых)
задается интегралом по единичной окружности от некоторого ряда.
Этот интеграл разбивается на два, один из которых оценивается, а про другой доказывается его относительная малость.
Составляющие первую сумму называются большими дугами, а вторую — малыми.
Позже этот метод был усовершенствован советским математиком Виноградовым.
Он доказал, что все нечетные целые числа, начиная с некоторого N, можно представить в виде суммы трех простых.
Число N оказалось достаточно большим - 106846168.
Позже делались попытки уменьшить это число.
В 2013 году перуанский математик Хельфготт окончательно доказал тернарную гипотезу.
Результатом трудов Хельфготта стала 133-страничная работа, которая содержит все необходимые оценки.
Главная теорема звучит следующим образом: все нечетные целые числа, большие 1029,
могут быть представлены в виде суммы трех простых. Ранее утверждение гипотезы Гольдбаха было проверено
(самим Хельфготтом в сотрудничестве с Давидом Платтом) до 8,875 x 1030.
Вместе эти два факта дают окончательное доказательство тернарной гипотезы Гольдбаха.
Тернарная гипотеза доказана с помощью аналитической теории чисел.
Свойства целых чисел она исследует методами математического анализа.
Первым шагом в этом направлении стал метод производящих функций, сформулированный Эйлером.
Для определения количества целочисленных неотрицательных решений линейного уравнения
a1x1 + ... + anxn = N
где a1, ... , an - натуральные числа, x1, ... , an - целые положительные числа.
Эйлер построил производящую функцию, которая определяется как произведение сходящихся рядов при z < 1
т.е. F(z) = F1(z) * ... * Fk(z), при этом каждый сходящийся ряд является суммой
бесконечной геометрической прогрессии
Поэтому
и является суммой членов геометрической прогрессии, при этом
где l(N) — число решений изучаемого уравнения. На основе этого метода был построен круговой метод Харди — Литлвуда.
Подробнее можно почитать в книге Р. Вонг - Метод Харди - Литтлвуда.
Гипотеза Варинга
Гипотеза Варинга относится к числу доказанных гипотез. Она была впервые доказана Гильбертом еще в начале 20-века.
Она оказала большое влияние на разитие теории чисел и послужила источником других важных гипотез,
а также полужила толчком для развития аналитической теории чисел.
Гипотеза Варинга звучит так:
Для каждого целого n > 1 существует такое число k = k(n), что всякое натуральное число N может быть представлено в виде:
x1n + x2n + ... + xkn = N
с целыми положительными x1, x22, ..., xk
Как гипотеза предложена в 1770 году Эдвардом Варингом.
До 20 века были доказаны частные случаи, например в 1770 году Лагранж доказал, что для n=2 k=4.
Харди и Литтлвуд ввели для этой гипотезы две специальных функции - g(n) и G(n).
g(n) - это min(k) , а G(n) - это min(g(n)).
Функция g(n) известна, в отличие от G(n).
Для G(n) известно, что G(n) >= n+1 и G(n) < 3n(ln(n) + ).
Несколько первых значений g(n):
1, 4, 9, 19, 37, 73, 143, 279, 548, 1 079, 2 132, 4 223, 8 384, 16 673, 33 203, 66 190, 132 055
Т.е. любое число может быть разложено на сумму четырех квадратов, равно как и на сумму девяти кубов, и т.д.
Все натуральные числа, за исключением чисел вида 4m(8n+7), могут быть представлены в виде суммы трех квадратов.
Подробнее о доказательстве гипотезы Варинга можно почитать тут:
Ю.В.Нестеренко - О проблеме Варинга.
Следующий код разлагает натуральные числа, идущие подряд, начиная с N=1010, на сумму четырех квадратов:
Код
package main
import (
"math/big"
)
var (
ZERO = big.NewInt(0)
ONE = big.NewInt(1)
TWO = big.NewInt(2)
THREE = big.NewInt(3)
FOR = big.NewInt(4)
EIGHT = big.NewInt(8)
TEN = big.NewInt(10)
ELEWEN = big.NewInt(11)
)
func get_a(a *big.Int, p *big.Int) (bool) {
mod, div := ZERO, ZERO
found := false
p1 := ZERO.Sub(p, ONE)
p11 := ZERO.Div(p1, big.NewInt(2))
a1 := new(big.Int).Exp(a, p11, nil)
a2 := new(big.Int).Add(a1, ONE)
div.DivMod(a2, p, mod)
if div.Cmp(ZERO) == 1 && mod.Cmp(ZERO) == 0 && a.Cmp(p) == -1{
found = true
}
return found
}
func get_x(a *big.Int, p *big.Int) (bool, *big.Int) {
mod, div := big.NewInt(0), big.NewInt(0)
found := false
p1 := big.NewInt(0).Sub(p, ONE)
p22 := new(big.Int).Div(p1, big.NewInt(4))
x := new(big.Int).Exp(a, p22, nil)
xx22 := new(big.Int).Mul(x,x)
xx22 = xx22.Add(xx22, ONE)
div.DivMod(xx22, p, mod)
if mod.Cmp(ZERO) == 0{
found = true
}
return found, x
}
func SqrtBig(n *big.Int) (x *big.Int) {
switch n.Sign() {
case -1:
return big.NewInt(0)
case 0:
return big.NewInt(0)
}
var px, nx big.Int
x = big.NewInt(0)
x.SetBit(x, n.BitLen()/2+1, 1)
for {
nx.Rsh(nx.Add(x, nx.Div(n, x)), 1)
if nx.Cmp(x) == 0 || nx.Cmp(&px) == 0 {
break
}
px.Set(x)
x.Set(&nx)
}
return
}
// определяем, является ли натуральное число числом вида 4k+1
func get_4k_plus_1(p *big.Int) bool {
mod, div := big.NewInt(0), big.NewInt(0)
p1 := big.NewInt(0).Sub(p, big.NewInt(1))
div.DivMod(p1, big.NewInt(4), mod)
if mod.Cmp(big.NewInt(0)) == 0{ return true}
return false
}
// определяем, является ли натуральное число числом вида 4k+1
func get_8k_plus_3(p *big.Int) bool {
mod, div := big.NewInt(0), big.NewInt(0)
p1 := big.NewInt(0).Sub(p, big.NewInt(3))
div.DivMod(p1, big.NewInt(8), mod)
if mod.Cmp(big.NewInt(0)) == 0{ return true}
return false
}
func get_4k(p *big.Int) bool {
mod, div := big.NewInt(0), big.NewInt(0)
div.DivMod(p, big.NewInt(4), mod)
if mod.Cmp(big.NewInt(0)) == 0{ return true}
return false
}
func mods(a *big.Int, n *big.Int) (*big.Int){
if n.Cmp(big.NewInt(0)) == 0 || n.Cmp(big.NewInt(0)) == -1 {
return big.NewInt(0)
}
div, mod := big.NewInt(0), big.NewInt(0)
div.DivMod(a, n, mod)
a = mod
m2 := big.NewInt(0).Mul(a,TWO)
if m2.Cmp(n) ==1 {
a.Sub(a, n)
}
return a
}
func powmods(a *big.Int, r *big.Int, n *big.Int)(*big.Int){
out := big.NewInt(1)
for {
if r.Cmp(big.NewInt(0)) != 1{break}
div, mod, rr := big.NewInt(0), big.NewInt(0), big.NewInt(0)
rr = big.NewInt(0).Set(r)
div.DivMod(rr, big.NewInt(2), mod)
if mod.Cmp(big.NewInt(1)) == 0{
r.Sub(r, big.NewInt(1))
outa := big.NewInt(0).Mul(out, a)
out = mods(outa, n)
}
r = big.NewInt(0).Div(r, big.NewInt(2))
aa := big.NewInt(0).Mul(a, a)
a = mods(aa, n)
}
return out
}
func quos(a *big.Int, n *big.Int)(*big.Int){
if n.Cmp(big.NewInt(0)) == 0 || n.Cmp(big.NewInt(0)) == -1 {
return big.NewInt(0)
}
an := mods(a, n)
a1 := big.NewInt(0).Sub(a, an)
a2 := big.NewInt(0).Div(a1, n)
return a2
}
func grem(ww0 *big.Int, ww1 *big.Int, zz0 *big.Int, zz1 *big.Int)(*big.Int, *big.Int){
w0, w1 := ww0, ww1
z0, z1 := zz0, zz1
zzz0 := big.NewInt(0).Mul(z0, z0)
zzz1 := big.NewInt(0).Mul(z1, z1)
n := big.NewInt(0).Add(zzz0, zzz1)
if n.Cmp(ZERO) == 0{return big.NewInt(0), big.NewInt(0)}
www0 := big.NewInt(0).Mul(w0, z0)
www1 := big.NewInt(0).Mul(w1, z1)
www2 := big.NewInt(0).Add(www0, www1)
u0 := quos(www2,n)
www0 = big.NewInt(0).Mul(w1, z0)
www1 = big.NewInt(0).Mul(w0, z1)
www2 = big.NewInt(0).Sub(www0, www1)
u1 := quos(www2,n)
zu0 := big.NewInt(0).Mul(z0, u0)
zu1 := big.NewInt(0).Mul(z1, u1)
wzu := big.NewInt(0).Sub(w0, zu0)
r1 := big.NewInt(0).Add(wzu, zu1)
zu01 := big.NewInt(0).Mul(z0, u1)
zu10 := big.NewInt(0).Mul(z1, u0)
wzu1 := big.NewInt(0).Sub(w1, zu01)
r2 := big.NewInt(0).Sub(wzu1, zu10)
return r1 , r2
}
func ggcd(w1 *big.Int, w2 *big.Int, z1 *big.Int, z2 *big.Int)(*big.Int, *big.Int){
zz1 := big.NewInt(0)
zz2 := big.NewInt(0)
ww1 := big.NewInt(0)
ww2 := big.NewInt(0)
for{
zz1.Set(z1)
zz2.Set(z2)
ww1.Set(w1)
ww2.Set(w2)
z1, z2 = grem(ww1, ww2, zz1, zz2)
w1.Set(zz1)
w2.Set(zz2)
if w1.Cmp(big.NewInt(0)) == 0 && w2.Cmp(big.NewInt(0)) == 0 {break}
}
return z1, z2
}
func root4(p *big.Int)(*big.Int){
j := big.NewInt(2)
c := 0
for{
k := big.NewInt(0).Div(p, big.NewInt(4))
a := powmods(j, k, p)
aa := big.NewInt(0).Mul(a,a)
b := mods(aa, p)
if b.Cmp(big.NewInt(0)) == -1{ return a }
if b.Cmp(big.NewInt(1)) != 0 { return big.NewInt(0) }
j.Add(j, big.NewInt(1))
c += 1
}
return ZERO
}
func sq2(p *big.Int)(*big.Int, *big.Int){
a := root4(p)
b, c := ggcd(p, ZERO, a, ONE)
return b, c
}
func get_q(n *big.Int) (* big.Int,* big.Int){
x111 := SqrtBig(n)
x22 := big.NewInt(0).Mul(x111,x111)
return x111,x22
mod, div := big.NewInt(0), big.NewInt(0)
if x22.Cmp(n) == 0 { // n является квадратом - вычисляем наименьший четный корень
x111 = x111.Sub(x111, big.NewInt(1))
div.DivMod(x111, big.NewInt(2), mod)
if mod.Cmp(big.NewInt(0)) != 0{
x111 = x111.Sub(x111,big.NewInt(1))
}
} else { // n не является квадратом
div.DivMod(x111, big.NewInt(2), mod)
if mod.Cmp(big.NewInt(0)) != 0{ // если корень - нечетное число
x111 = x111.Sub(x111,big.NewInt(1))
}
}
residue := big.NewInt(0).Sub(n, x111)
residue = residue.Sub(residue, big.NewInt(7))
div.DivMod(residue, big.NewInt(8), mod)
if mod.Cmp(big.NewInt(0)) == 0 { // если да - то отнимаем два
x111 = x111.Sub(x111, big.NewInt(2))
}
x1111 := big.NewInt(0).Mul(x111, x111)
return x111, x1111
}
func get_squares_from_test(test_number *big.Int, exp int64, _count int)(bool){
found := false
b, c := big.NewInt(0), big.NewInt(0)
x03, x3 := big.NewInt(0), big.NewInt(0)
x04, x4 := big.NewInt(0), big.NewInt(0)
if get_4k(test_number){
div, mod := big.NewInt(0), big.NewInt(0)
tn := big.NewInt(0).Div(test_number, big.NewInt(4))
ttt := big.NewInt(2)
for {
count := 0
x04, x4 = get_q(tn)
for {
n_type, n := get_type_of_n(tn, x4)
x03, x3 = get_q(n)
if n_type==41 || n_type==83 || n_type == 4 {
if n_type==41 {
found, b, c = get_squares_from_41(x03, x3, x04, n)
if found { break}
} else if n_type==83 {
found, b, c = get_squares_from_83(x03, x3, x04, n)
if found { break}
}
}
x04 = big.NewInt(0).Sub(x04, big.NewInt(1))
x4 = big.NewInt(0).Mul(x04, x04)
count +=1
if x04.Cmp(big.NewInt(1)) == -1{break}
if count == 10000{break}
}
if found {
xx1 := big.NewInt(0).Mul(b, ttt)
xx2 := big.NewInt(0).Mul(c, ttt)
xx3 := big.NewInt(0).Mul(x03, ttt)
xx4 := big.NewInt(0).Mul(x04, ttt)
sss1 := big.NewInt(0).Mul(xx1, xx1)
sss2 := big.NewInt(0).Mul(xx2, xx2)
sss3 := big.NewInt(0).Mul(xx3, xx3)
sss4 := big.NewInt(0).Mul(xx4, xx4)
ss1 := big.NewInt(0).Add(sss1, sss2)
ss2 := big.NewInt(0).Add(sss3, sss4)
sss := big.NewInt(0).Add(ss1, ss2)
sss = sss
println("10^", exp, "+", _count, "=", xx1.String(), "^2 +", xx2.String(), "^2 +", xx3.String(), "^2 +", xx4.String(), "^2" )
return true
}
div.DivMod(tn, big.NewInt(4), mod)
if mod.Cmp(big.NewInt(0)) == 0 {
ttt = ttt.Mul(ttt, big.NewInt(2))
tn.Div(tn, big.NewInt(4))
} else {
break
}
}
}
return found
}
func get_type_of_n(test_number *big.Int, x4 *big.Int)(int, *big.Int){
n_type := 0
n := big.NewInt(0).Sub(test_number, x4)
if get_4k_plus_1(n){
n_type = 41
}else if get_8k_plus_3(n){
n_type = 83
}else if get_4k(n){
n_type = 4
}
return n_type, n
}
func get_squares_from_41(x03 *big.Int, x3 *big.Int, x04 *big.Int, n *big.Int) (bool, *big.Int, *big.Int){
find := false
b, c := big.NewInt(0),big.NewInt(0)
p := big.NewInt(0).Sub(n, x3)
if p.ProbablyPrime(100){
if get_4k_plus_1(p){
b, c = sq2(p)
find = true
}
}
return find, b, c
}
func get_squares_from_83(x03 *big.Int, x3 *big.Int, x04 *big.Int, n *big.Int) (bool, *big.Int, *big.Int){
find := false
bc1, bc2 := big.NewInt(0),big.NewInt(0)
mod, div := new(big.Int), new(big.Int)
p := big.NewInt(0).Sub(n, x3)
div.DivMod(p, big.NewInt(2), mod)
if mod.Cmp(big.NewInt(0)) == 0 {
if div.ProbablyPrime(100){
if get_4k_plus_1(div){
b, c := sq2(div)
if b.Cmp(big.NewInt(0)) == -1 {
b = big.NewInt(0).Mul(b, big.NewInt(-1))
}
if c.Cmp(big.NewInt(0)) == -1 {
c = big.NewInt(0).Mul(c, big.NewInt(-1))
}
bc1 = big.NewInt(0).Add(b, c)
bc2 = big.NewInt(0).Sub(b, c)
find = true
}
}
}
return find, bc1, bc2
}
func main() {
exp := int64(10)
test_number := new(big.Int).Exp(big.NewInt(10), big.NewInt(exp), nil)
count := 0
for
{
if get_squares_from_test(test_number, exp, count) {
test_number.Add(test_number, big.NewInt(1))
count += 1
continue
}
x04, x4 := get_q(test_number)
found := false
for {
n_type, n := get_type_of_n(test_number, x4)
x03, x3 := get_q(n)
//println(n_type)
if n_type==41 || n_type==83 {
for {
if n_type==41 {
_found, f1, f2 := get_squares_from_41(x03, x3, x04, n)
if _found == true {
println("10^", exp, "+", count, "=", f1.String(), "^2 + ", f2.String(), "^2 + ", x03.String(), "^2 + ", x04.String(), "^2 ")
found = true
break
}
} else if n_type==83 {
_found, f1, f2 := get_squares_from_83(x03, x3, x04, n)
if _found == true {
println("10^", exp, "+", count, "=", f1.String(), "^2 + ", f2.String(), "^2 + ", x03.String(), "^2 + ", x04.String(), "^2 ")
found = true
break
}
}
x03 = big.NewInt(0).Sub(x03, big.NewInt(1))
if x03.Cmp(big.NewInt(1)) == -1{break}
x3 = big.NewInt(0).Mul(x03, x03)
if x3.Cmp(big.NewInt(1)) == -1{break}
}
}
if found == true {break}
x04 = big.NewInt(0).Sub(x04, big.NewInt(1))
if x04.Cmp(big.NewInt(1)) == -1{break}
x4 = big.NewInt(0).Mul(x04, x04)
if x4.Cmp(big.NewInt(1)) == -1 {break}
}
test_number.Add(test_number, big.NewInt(1))
count += 1
}
}
Гипотеза Артина
Гипотеза Артина — это гипотеза о существовании и количественной оценке простых чисел, по модулю которых заданное целое число является первообразным корнем.
Формулировка:
Для любого целого числа a, не являющегося точным квадратом и отличного от -1, существует бесконечно много простых чисел,
по модулю которых a является первообразным корнем. Более того, для количества таких простых чисел не превышающих x справедлива асимптотика:
N = x / ln(x)
В настоящий момент неизвестно даже, верна ли гипотеза для конкретного числа a=2.
Число 2 является первообразным корнем, в частности, по модулю 3 и по модулю 5, но не по модулю 7. Последовательность простых чисел, по модулю которых 2 является первообразным корнем, начинается так:
3, 5, 11, 13, 19, 29, 37, 53, 59, 61, 67, 83, 101, ...
Следующий код показывает, что простых чисел, не превышающих 100000, у которых 2 является первообразным корнем, насчитывается 3604.
Код
package main
import (
"math"
"time"
"math/big"
)
func primes(nn int64) ([]int64){
var x, y, n int64
nsqrt := math.Sqrt(float64(nn))
is_prime := make([]bool, nn)
for x = 1; float64(x) <= nsqrt; x++ {
for y = 1; float64(y) <= nsqrt; y++ {
n = 4*(x*x) + y*y
if n <= nn && (n%12 == 1 || n%12 == 5) {
is_prime[n] = !is_prime[n]
}
n = 3*(x*x) + y*y
if n <= nn && n%12 == 7 {
is_prime[n] = !is_prime[n]
}
n = 3*(x*x) - y*y
if x > y && n <= nn && n%12 == 11 {
is_prime[n] = !is_prime[n]
}
}
}
for n = 5; float64(n) <= nsqrt; n++ {
if is_prime[n] {
for y = n*n; y < nn; y += n*n {
is_prime[y] = false
}
}
}
is_prime[2] = true
is_prime[3] = true
primes := make([]int64, 0, 1270606)
for x = 2; x < int64(len(is_prime)-1); x++ {
if is_prime[x] {
if x > 1 {
primes = append(primes, x)
}
}
}
return primes
}
func factors(n int64) []int64{
s := make([]int64, 0)
s = append(s, 1)
i := int64(2)
for{
if i > n/2{
break
}
if n % i == 0{
s = append(s, i)
}
i += 1
}
s = append(s, n)
return s
}
func primitive_root(p int64) int64{
pd := factors(p-1)
pd = append(pd[:0], pd[1:]...)
p2 := int64(2)
_pow2 := big.NewInt(0)
for {
if p2 >= p{
break
}
for _, d := range pd{
_ppp := int64((p-1)/d)
big_pow := new(big.Int).Exp(big.NewInt(p2), big.NewInt(_ppp), nil)
_pow2 = big_pow.Mod(big_pow, big.NewInt(int64(p)))
if _pow2.Cmp(big.NewInt(1)) == 0{
break
}
}
if _pow2.Cmp(big.NewInt(1)) !=0 {
return p2
}
p2 += 1
}
return p2
}
func main() {
t1 := time.Now()
pp := primes(100000)
count := 0
for _, p := range pp{
x := primitive_root(p)
if x == 2 {
count +=1
println(p, x, count)
}
}
t2 := time.Since(t1)
println(t2.Seconds())
}
Гипотеза Ризеля
Число Ри́зеля — нечётное натуральное число k, для которого целые числа вида
k·2n − 1
составные для всех натуральных чисел n.
В 1956 году Ханс Ризель доказал, что существует бесконечное число таких целых чисел k.
Он показал, что этим свойством обладает число 509203, а также 509203 плюс любое натуральное число, умноженное на 11 184 810.
Известные числа Ризеля меньшие миллиона:
762701·2n − 1 777149·2n − 1 790841·2n − 1 992077·2n − 1
Проблема Ризеля состоит в определении наименьшего числа Ризеля. Так как ни для одного числа k < 509203 не найдено покрывающее множество,
то предполагается, что 509203 является наименьшим числом Ризеля.
Однако, по состоянию на февраль 2015 года для 50 значений k < 509203 последовательность содержит только составные числа для всех проверенных значений n.
Вот они:
2293, 9221, 23 669, 31 859, 38 473, 46 663, 67 117, 74 699, 81 041, 93 839, 97 139, 107 347, 121 889, 129 007, 143 047, 146 561, 161 669, 192 971, 206 039, 206 231, 215 443, 226 153, 234 343, 245 561, 250 027, 273 809, 315 929, 319 511, 324 011, 325 123, 327 671, 336 839, 342 847, 344 759, 362 609, 363 343, 364 903, 365 159, 368 411, 371 893, 384 539, 386 801, 397 027, 409 753, 444 637, 470 173, 474 491, 477 583, 485 557, 494 743.
С гипотезой Ризеля перекликается гипотеза Серпинского.
Числа Серпинского отличаются от чисел Ризеля лишь знаком:
k·2n + 1
Последовательность известных на данный момент чисел Серпинского начинается так:
78 557, 271 129, 271 577, 322 523, 327 739, 482 719, 575 041, 603 713, 903 983, 934 909, 965 431, 1 259 779, 1 290 677, 1 518 781, 1 624 097, 1 639 459, 1 777 613, 2 131 043, 2 131 099, 2 191 531, 2 510 177, 2 541 601, 2 576 089, 2 931 767, 2 931 991, 3 083 723, 3 098 059, 3 555 593, 3 608 251,
Натуральное число может быть одновременно числом Ризеля и числом Серпинского, например
143665583045350793098657, 623506356601958507977841221247, 3872639446526560168555701047, 878503122374924101526292469
Такие числа называются числами Бриэра (Brier number).
Подробнее можно почитать тут и тут.
Открытым является вопрос бесконечности количества простых чисел в каждой из следующих последовательностей:
Решение за 1997г. бинарной и тернарной Гипотезы Гольдбаха можно прочитать в книге:
На данный момент книга доступна на Озон.
https:www.ozon.ruproductreshenie-znamenityh-matematicheskih-problem-531746209?sh=lUPMEumO2g
Решение за 2022 г. бинарной и тернарной Гипотезы Гольдбаха можно прочитать вот здесь:
https://disk.yandex.ru/i7igGJ1l1qAM6rw
2022-04-09 22:31:50