Channel sending but receiver only receives every other message

I'm trying to write a program where channels are generated and information is passed through a pipeline. I have one channel that is receiving from an upstream channel and simply passing it down to the next channel, for a certain number of times. My problem is that it seems like that function is sending the inputs to the next channel, but on the receiving side, only every other message is received and printed. I'm not quite sure what is going on.

Here is the code:

//Function that receives an array of [3]Point3D, and then sends it to the outputStream n times
func takeN(inputStream <-chan [3]Point3D, closeInputStream chan<- bool, n int) <-chan [3]Point3D {
	outputStream := make(chan [3]Point3D)
	go func() {
		//Receives points n times and resends them
		for i := 0; i < n; i++ {
			in := <-inputStream
			outputStream <- in
			fmt.Println("out from takeN: ", in)
		}

		//Terminate initial stage of the pipeline once done
		closeInputStream <- true

		//Close the output stream to let downstream functions know there won't be any more outputs
		close(outputStream)
		return
	}()
	return outputStream
}


func main() {

	// Channel used to send the stop signal for the upstream portion of the pipeline
	stopChan := make(chan bool)
        //Channels that generate inputs for takeNChan
	singlePointChan := RandomGenerator(stopChan, pointCloud)
	triplePointChan := TripletGenerator(singlePointChan)

	takeNChan := takeN(triplePointChan, stopChan, 10)

        //Here is the problem: this print statement is only executed 5 times, when it should be executed 10 times. Even with a buffered channel, it only prints 5 times
	for range takeNChan {
		received := <-takeNChan
		fmt.Println("main takeNchan: ", received)
	}

	time.Sleep(time.Second * 5)
}

In the main function, the received message is only printed 5 times (should be 10).

When I run the code, I get the following output:

out from takeN:  [{-2.74 -11.45 2.52} {-7.26 -11.21 2.72} {9.96 -1.3 -0.83}]
out from takeN:  [{5.46 2.68 -0.72} {1.15 -11.61 3.18} {0.22 -3.58 -0.29}]  
main takeNchan:  [{5.46 2.68 -0.72} {1.15 -11.61 3.18} {0.22 -3.58 -0.29}]  
out from takeN:  [{-1.98 -4.16 -0.89} {3.71 -2.35 -0.85} {0.51 4.47 -0.75}] 
out from takeN:  [{0.4 -3.34 0} {63.21 -7.23 2.88} {-1.43 -11.51 3.41}]     
main takeNchan:  [{0.4 -3.34 0} {63.21 -7.23 2.88} {-1.43 -11.51 3.41}]     
out from takeN:  [{-3.61 6.79 0.01} {1.14 5.29 -0.15} {12.73 9.59 2.49}]    
out from takeN:  [{-2.07 -4.47 -0.59} {1.95 2.27 -0.79} {26.1 13.95 -0.27}] 
main takeNchan:  [{-2.07 -4.47 -0.59} {1.95 2.27 -0.79} {26.1 13.95 -0.27}] 
out from takeN:  [{5.39 -0.66 -0.8} {29.96 11.26 0.02} {8.17 9.86 1.76}]    
out from takeN:  [{2.28 2.21 -0.77} {6.91 -7.32 -0.55} {4.77 -0.25 -0.79}]  
main takeNchan:  [{2.28 2.21 -0.77} {6.91 -7.32 -0.55} {4.77 -0.25 -0.79}]  
out from takeN:  [{-0.99 -3.73 -0.46} {-4.26 7.85 -0.65} {1.33 -11.6 3.57}] 
out from takeN:  [{5.31 -11.23 -0.11} {2.01 2.47 -0.78} {5.24 -11.25 -0.45}]
main takeNchan:  [{5.31 -11.23 -0.11} {2.01 2.47 -0.78} {5.24 -11.25 -0.45}]

As you can see, only every other output is received and printed in the main() function 5 times, with every other message sent from the takeN function.

From my understanding, the print "out from takeN" should only execute once a message is sent on the line before because the code within the goroutine is sequential right? I thought that messages shouldn't be sent out of the channel until there is a receiver ready, so why are messages being sent out and seemingly not received?

The program hangs for a bit at the end due to the time.Sleep, so I don't think it's because the main program is exiting early.
I've also tried making the output channel buffered but that didn't work either.

You are receiving from the channel twice - and discarding the first value. Change this:

for range takeNChan {
    received := <-takeNChan
    fmt.Println("main takeNchan: ", received)
}

to:

for received := range takeNChan {
    fmt.Println("main takeNchan: ", received)
}