trying to implement lock-free fixedsize queue

[jacob via Digitalmars-d-learn]

I try to implement chunk (something like lock-free fixedsize 
queue)
--
import core.atomic;

shared struct Chunk(T, uint N)
{
	shared T[N] data;
	shared uint count;
	shared uint queueCounter;

	@property uint capacity() { return N; }
	@property uint count() { return count; }
	@property bool full() { return count == N; }

	void append(shared T value)
	{
		atomicOp!("+=")(queueCounter, 1);
		while(1)
		{
			uint c = count;
			if(cas(&count, c, c + 1))
			{
				data[c] = value;
				atomicOp!("-=")(queueCounter, 1);
				break;
			}
		}		
	}

	bool waitAll()
	{
		if(!full())
		{
			return false;
		}

		while(0 != queueCounter)
		{
		}

		return true;
	}
}
--

And call it like:

--
import std.parallelism;

struct S
{
     bool dirty;
     int time;
     int[16] data;
}

int main(string[] argv)
{
     const uint N = 14344;

     shared Chunk!(S, N) ch;

     foreach(i; taskPool.parallel(std.range.iota(N), 10))
     {
         shared S item;
         item.time = i;
         ch.append(item);
     }
     while(!ch.waitAll()) {}

     // DONE

     return 0;
}
--

It works fine with N == 14343, but fails without any message with 
14344 (value depends on computer).

Why does program fail?

Am I doing correct CAS append?