# Chroma Style Gallery

## abap

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## algol

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## algol_nu

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## arduino

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## autumn

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## average

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## base16-snazzy

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## borland

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## bw

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## catppuccin-frappe

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## catppuccin-latte

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## catppuccin-macchiato

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## catppuccin-mocha

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## colorful

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## doom-one

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## doom-one2

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## dracula

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## emacs

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## evergarden

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## friendly

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## fruity

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## github-dark

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## github

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## gruvbox-light

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## gruvbox

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## hr_high_contrast

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## hrdark

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## igor

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## lovelace

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## manni

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## modus-operandi

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## modus-vivendi

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## monokai

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## monokailight

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## murphy

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## native

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## nord

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## nordic

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## onedark

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## onesenterprise

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## paraiso-dark

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## paraiso-light

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## pastie

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## perldoc

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## pygments

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## rainbow_dash

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## rose-pine-dawn

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## rose-pine-moon

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## rose-pine

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## rrt

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## solarized-dark

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## solarized-dark256

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## solarized-light

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## swapoff

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## tango

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## tokyonight-day

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## tokyonight-moon

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## tokyonight-night

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## tokyonight-storm

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## trac

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## vim

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## vs

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## vulcan

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## witchhazel

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## xcode-dark

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

## xcode

```package main import "fmt" // calculateSquares calculates the sum of the squares of the digits of the given number // and sends the result to the squareop channel. func calculateSquares(number int, squareop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit number /= 10 } squareop <- sum } // calculateCubes calculates the sum of the cubes of the digits of the given number // and sends the result to the cubeop channel. func calculateCubes(number int, cubeop chan int) { sum := 0 for number != 0 { digit := number % 10 sum += digit * digit * digit number /= 10 } cubeop <- sum } func main() { number := 589 sqrch := make(chan int) cubech := make(chan int) // Start two goroutines to calculate the sum of squares and cubes of the digits. go calculateSquares(number, sqrch) go calculateCubes(number, cubech) // Receive the results from the channels and add them. squares, cubes := <-sqrch, <-cubech fmt.Println("Final result", squares+cubes) }```

Back to overview

Gallery with shorter code samples

Generated 2024-08-28 by xyproto using splash.