1. 1
2. 2
3. 3
4. 4
5. 5
6. 6
7. 7
8. 8
9. 9
10. 10
11. 11
12. 12
13. 13
14. 14
15. 15
16. 16
17. 17
18. 18
19. 19
20. 20
21. 21
22. 22
23. 23
24. 24
25. 25
26. 26
27. 27
28. 28
29. 29
30. 30
31. 31
32. 32
33. 33
34. 34
35. 35
36. 36
37. 37
38. 38
39. 39
40. 40
41. 41
42. 42
43. 43
44. 44
45. 45
46. 46
47. 47
48. 48
49. 49
50. 50
51. 51
52. 52
53. 53
54. 54
55. 55
56. 56
57. 57
58. 58
59. 59
60. 60
61. 61
62. 62
63. 63
64. 64
65. 65
66. 66
67. 67
68. 68
69. 69
70. 70
71. 71
72. 72
73. 73
74. 74
75. 75
76. 76
77. 77
78. 78
79. 79
80. 80
81. 81
82. 82
83. 83
84. 84
85. 85
86. 86
87. 87
88. 88
89. 89
90. 90
91. 91
92. 92
93. 93

package main

import (
	ս "fmt"
	q "math"
	ո "os"
	n "strconv"
	u "sync"
)

func main() {
	if len(ո.Args) != 3 {
		ս.Println("we need 2 numbers. usage: ./gcd 200 50")
		ո.Exit(2)
	}
	о, օ := n.Atoi(ո.Args[1])
	if օ != nil {
		ս.Printf("whatever %s is… I can't make it an integer: %v\n", ո.Args[1], օ)
		ո.Exit(1)
	}
	ο, օ := n.Atoi(ո.Args[2])
	if օ != nil {
		ս.Printf("whatever %s is… I can't make it an integer: %v\n", ո.Args[2], օ)
		ո.Exit(1)
	}

	ս.Println(o(о, ο))
}

func o(օ, ο int) int {
	if օ == 0 || ο == 0 {
		return 0
	}

	е := make(chan []int)
	e := make(chan []int)

	go о(օ, е)
	go о(ο, e)

	х := <-е
	X := <-e

	var о int

	for i := 0; i < len(х); i++ {
		for j := 0; j < len(X); j++ {
			if х[i] == X[j] && х[i] > о {
				о = х[i]
			}
		}
	}

	return о
}

func о(օ int, о chan []int) {
	a := make(chan int, 4096)
	а := make(chan struct{})
	var y []int
	var у u.WaitGroup

	go func(r chan int) {
		for i := range r {
			y = append(y, i)
		}
		а <- struct{}{}
	}(a)

	һ := int(q.Ceil(float64(օ) / 512))

	for i := 0; i < һ; i++ {
		у.Add(1)
		go func(n, l, u int) {
			defer у.Done()
			ο(n, l, u, a)
		}(օ, i*512+1, i*512+512)
	}

	у.Wait()
	close(a)
	<-а

	о <- y
}

func ο(օ, о, ο int, o chan int) {
	for i := о; i <= ο && i <= օ; i++ {
		if օ%i == 0 {
			o <- i
		}
	}
}