Index: libcfa/src/concurrency/io/setup.cfa
===================================================================
--- libcfa/src/concurrency/io/setup.cfa	(revision d119d613d96b2bbb128789cdb7cae928896836d7)
+++ libcfa/src/concurrency/io/setup.cfa	(revision ceb7db879ed40e636eabeaaa05e4a5c1c2daddec)
@@ -384,5 +384,5 @@
 			/* paranoid */ verify( is_pow2( params_in.num_ready ) || (params_in.num_ready < 8) );
 			sq.ready_cnt = max( params_in.num_ready, 8 );
-			sq.ready = alloc_align( 64, sq.ready_cnt );
+			sq.ready = alloc( sq.ready_cnt, 64`align );
 			for(i; sq.ready_cnt) {
 				sq.ready[i] = -1ul32;
Index: libcfa/src/concurrency/ready_queue.cfa
===================================================================
--- libcfa/src/concurrency/ready_queue.cfa	(revision d119d613d96b2bbb128789cdb7cae928896836d7)
+++ libcfa/src/concurrency/ready_queue.cfa	(revision ceb7db879ed40e636eabeaaa05e4a5c1c2daddec)
@@ -547,5 +547,5 @@
 
 		// Allocate new array (uses realloc and memcpies the data)
-		lanes.data = alloc(lanes.data, ncount);
+		lanes.data = alloc( ncount, lanes.data`realloc );
 
 		// Fix the moved data
@@ -638,5 +638,5 @@
 
 		// Allocate new array (uses realloc and memcpies the data)
-		lanes.data = alloc(lanes.data, lanes.count);
+		lanes.data = alloc( lanes.count, lanes.data`realloc );
 
 		// Fix the moved data
Index: libcfa/src/stdlib.hfa
===================================================================
--- libcfa/src/stdlib.hfa	(revision d119d613d96b2bbb128789cdb7cae928896836d7)
+++ libcfa/src/stdlib.hfa	(revision ceb7db879ed40e636eabeaaa05e4a5c1c2daddec)
@@ -114,141 +114,134 @@
 } // distribution
 
+/*
+	FIX ME : fix alloc interface after Ticker Number 214 is resolved, define and add union to S_fill. Then, modify postfix-fill functions to support T * with nmemb, char, and T object of any size. Finally, change alloc_internal.
+	Or, just follow the instructions below for that.
+
+	1. Replace the current forall-block that contains defintions of S_fill and S_realloc with following:
+		forall( dtype T | sized(T) ) {
+			union  U_fill 		{ char c; T * a; T t; };
+			struct S_fill 		{ char tag; char c; size_t size; T * at; char t[50]; };
+			struct S_realloc	{ inline T *; };
+		}
+
+	2. Replace all current postfix-fill functions with following for updated S_fill:
+		S_fill(T) ?`fill( char a )					{ S_fill(T) ret = {'c'}; ret.fill.c = a; return ret; }
+		S_fill(T) ?`fill( T    a ) 					{ S_fill(T) ret = {'t'}; memcpy(&ret.fill.t, &a, sizeof(T)); return ret; }
+		S_fill(T) ?`fill( T    a[], size_t nmemb ) 	{ S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; }
+
+	3. Replace the $alloc_internal function which is outside ttype forall-block with following function:
+		T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
+			T * ptr = NULL;
+			size_t size = sizeof(T);
+			size_t copy_end = 0;
+
+			if(Resize) {
+				ptr = (T*) (void *) resize( (int *)Resize, Align, Dim * size );
+			} else if (Realloc) {
+				if (Fill.tag != '0') copy_end = min(malloc_size( Realloc ), Dim * size);
+				ptr = (T*) (void *) realloc( (int *)Realloc, Align, Dim * size );
+			} else {
+				ptr = (T*) (void *) memalign( Align, Dim * size );
+			}
+
+			if(Fill.tag == 'c') {
+				memset( (char *)ptr + copy_end, (int)Fill.fill.c, Dim * size - copy_end );
+			} else if(Fill.tag == 't') {
+				for ( int i = copy_end; i <= Dim * size - size ; i += size ) {
+					memcpy( (char *)ptr + i, &Fill.fill.t, size );
+				}
+			} else if(Fill.tag == 'a') {
+				memcpy( (char *)ptr + copy_end, Fill.fill.a, min(Dim * size - copy_end, size * Fill.nmemb) );
+			}
+
+			return ptr;
+		} // $alloc_internal
+*/
+
+typedef struct S_align 			{ inline size_t;  } T_align;
+typedef struct S_resize			{ inline void *;  }	T_resize;
+
+forall( dtype T ) {
+	struct S_fill 		{ char tag; char c; size_t size; T * at; char t[50]; };
+	struct S_realloc	{ inline T *; };
+}
+
+static inline T_align 	?`align   ( size_t a ) 	{ return (T_align){a}; }
+static inline T_resize 	?`resize  ( void * a )	{ return (T_resize){a}; }
 static inline forall( dtype T | sized(T) ) {
-	// Cforall safe general allocation, fill, resize, array
-
-	T * alloc( void ) {
-		return malloc();
-	} // alloc
-
-	T * alloc( size_t dim ) {
-		return aalloc( dim );
-	} // alloc
-
-	forall( dtype S | sized(S) )
-	T * alloc( S ptr[], size_t dim = 1 ) {				// singleton/array resize
-		return resize( (T *)ptr, dim * sizeof(T) );		// CFA resize
-	} // alloc
-
-	T * alloc( T ptr[], size_t dim = 1, bool copy = true ) {
-		if ( copy ) {
-			return realloc( ptr, dim * sizeof(T) );		// CFA realloc
+
+	S_fill(T) ?`fill ( T t ) {
+		S_fill(T) ret = { 't' };
+		size_t size = sizeof(T);
+		if(size > sizeof(ret.t)) { printf("ERROR: const object of size greater than 50 bytes given for dynamic memory fill\n"); exit(1); }
+		memcpy( &ret.t, &t, size );
+		return ret;
+	}
+	S_fill(T) 		?`fill ( char c ) 				{ return (S_fill(T)){ 'c', c };	}
+	S_fill(T) 		?`fill ( T * a ) 				{ return (S_fill(T)){ 'T', '0', 0, a }; }
+	S_fill(T) 		?`fill ( T a[], size_t nmemb ) 	{ return (S_fill(T)){ 'a', '0', nmemb * sizeof(T), a }; }
+
+	S_realloc(T) 	?`realloc ( T * a )				{ return (S_realloc(T)){a}; }
+
+	T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
+		T * ptr = NULL;
+		size_t size = sizeof(T);
+		size_t copy_end = 0;
+
+		if(Resize) {
+			ptr = (T*) (void *) resize( (int *)Resize, Align, Dim * size );
+		} else if (Realloc) {
+			if (Fill.tag != '0') copy_end = min(malloc_size( Realloc ), Dim * size);
+			ptr = (T*) (void *) realloc( (int *)Realloc, Align, Dim * size );
 		} else {
-			return resize( ptr, dim * sizeof(T) );		// CFA resize
-		} // if
-	} // alloc
-
-	T * alloc_set( char fill ) {
-		return (T *)memset( (T *)alloc(), (int)fill, sizeof(T) ); // initialize with fill value
-	} // alloc_set
-
-	T * alloc_set( const T & fill ) {
-		return (T *)memcpy( (T *)alloc(), &fill, sizeof(T) ); // initialize with fill value
-	} // alloc_set
-
-	T * alloc_set( size_t dim, char fill ) {
-		return (T *)memset( (T *)alloc( dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-	} // alloc_set
-
-	T * alloc_set( size_t dim, const T & fill ) {
-		T * r = (T *)alloc( dim );
-		for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
-		return r;
-	} // alloc_set
-
-	T * alloc_set( size_t dimNew, const T fill[], size_t dimOld ) {
-		return (T *)memcpy( (T *)alloc( dimNew ), fill, min( dimNew, dimOld ) * sizeof(T) ); // initialize with fill value
-	} // alloc_set
-
-	T * alloc_set( T ptr[], size_t dim, char fill ) {	// realloc array with fill
-		size_t osize = malloc_size( ptr );				// current allocation
-		size_t nsize = dim * sizeof(T);					// new allocation
-		T * nptr = realloc( ptr, nsize );				// CFA realloc
-		if ( nsize > osize ) {							// larger ?
-			memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
-		} // if
-		return nptr;
-	} // alloc_set
-
-	T * alloc_set( T ptr[], size_t dim, const T & fill ) {	// realloc array with fill
-		size_t odim = malloc_size( ptr ) / sizeof(T);	// current dimension
-		size_t nsize = dim * sizeof(T);					// new allocation
-		size_t ndim = nsize / sizeof(T);				// new dimension
-		T * nptr = realloc( ptr, nsize );				// CFA realloc
-		if ( ndim > odim ) {							// larger ?
-			for ( i; odim ~ ndim ) {
-				memcpy( &nptr[i], &fill, sizeof(T) );	// initialize with fill value
-			} // for
-		} // if
-		return nptr;
-	} // alloc_set
-} // distribution
-
-static inline forall( dtype T | sized(T) ) {
-	T * alloc_align( size_t align ) {
-		return (T *)memalign( align, sizeof(T) );
-	} // alloc_align
-
-	T * alloc_align( size_t align, size_t dim ) {
-		return (T *)memalign( align, dim * sizeof(T) );
-	} // alloc_align
-
-	T * alloc_align( T * ptr, size_t align ) {			// aligned realloc array
-		return (T *)(void *)realloc( (void *)ptr, align, sizeof(T) ); // CFA C realloc
-	} // alloc_align
-
-	forall( dtype S | sized(S) )
-	T * alloc_align( S ptr[], size_t align ) {			// aligned reuse array
-		return (T *)(void *)resize( (void *)ptr, align, sizeof(T) ); // CFA realloc
-	} // alloc_align
-
-	T * alloc_align( T ptr[], size_t align, size_t dim ) { // aligned realloc array
-		return (T *)(void *)realloc( (void *)ptr, align, dim * sizeof(T) ); // CFA realloc
-	} // alloc_align
-
-	T * alloc_align_set( size_t align, char fill ) {
-		return (T *)memset( (T *)alloc_align( align ), (int)fill, sizeof(T) ); // initialize with fill value
-	} // alloc_align_set
-
-	T * alloc_align_set( size_t align, const T & fill ) {
-		return (T *)memcpy( (T *)alloc_align( align ), &fill, sizeof(T) ); // initialize with fill value
-	} // alloc_align_set
-
-	T * alloc_align_set( size_t align, size_t dim, char fill ) {
-		return (T *)memset( (T *)alloc_align( align, dim ), (int)fill, dim * sizeof(T) ); // initialize with fill value
-	} // alloc_align_set
-
-	T * alloc_align_set( size_t align, size_t dim, const T & fill ) {
-		T * r = (T *)alloc_align( align, dim );
-		for ( i; dim ) { memcpy( &r[i], &fill, sizeof(T) ); } // initialize with fill value
-		return r;
-	} // alloc_align_set
-
-	T * alloc_align_set( size_t align, size_t dimNew, const T fill[], size_t dimOld ) {
-		return (T *)memcpy( (T *)alloc_align( align, dimNew ), fill, min( dimNew, dimOld ) * sizeof(T) );
-	} // alloc_align_set
-
-	T * alloc_align_set( T ptr[], size_t align, size_t dim, char fill ) {
-		size_t osize = malloc_size( ptr );				// current allocation
-		size_t nsize = dim * sizeof(T);					// new allocation
-		T * nptr = alloc_align( ptr, align, nsize );
-		if ( nsize > osize ) {							// larger ?
-			memset( (char *)nptr + osize, (int)fill, nsize - osize ); // initialize added storage
-		} // if
-		return nptr;
-	} // alloc_align_set
-
-	T * alloc_align_set( T ptr[], size_t align, size_t dim, const T & fill ) {
-		size_t odim = malloc_size( ptr ) / sizeof(T);	// current dimension
-		size_t nsize = dim * sizeof(T);					// new allocation
-		size_t ndim = nsize / sizeof(T);				// new dimension
-		T * nptr = alloc_align( ptr, align, nsize );
-		if ( ndim > odim ) {							// larger ?
-			for ( i; odim ~ ndim ) {
-				memcpy( &nptr[i], &fill, sizeof(T) );	// initialize with fill value
-			} // for
-		} // if
-		return nptr;
-	} // alloc_align_set
-} // distribution
+			ptr = (T*) (void *) memalign( Align, Dim * size );
+		}
+
+		if(Fill.tag == 'c') {
+			memset( (char *)ptr + copy_end, (int)Fill.c, Dim * size - copy_end );
+		} else if(Fill.tag == 't') {
+			for ( int i = copy_end; i <= Dim * size - size ; i += size ) {
+				memcpy( (char *)ptr + i, &Fill.t, size );
+			}
+		} else if(Fill.tag == 'a') {
+			memcpy( (char *)ptr + copy_end, Fill.at, min(Dim * size - copy_end, Fill.size) );
+		} else if(Fill.tag == 'T') {
+			for ( int i = copy_end; i <= Dim * size - size ; i += size ) {
+				memcpy( (char *)ptr + i, Fill.at, size );
+			}
+		}
+
+		return ptr;
+	} // $alloc_internal
+
+	forall( ttype TT | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
+
+		T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
+	        return $alloc_internal( Resize, (T*)0p, Align, Dim, Fill, rest);
+		}
+
+		T * $alloc_internal( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
+	        return $alloc_internal( (void*)0p, Realloc, Align, Dim, Fill, rest);
+		}
+
+		T * $alloc_internal( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
+	        return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
+		}
+
+		T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
+	        return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
+		}
+
+	    T * alloc( TT all ) {
+	    	return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
+	    }
+
+	    T * alloc( size_t dim, TT all ) {
+	    	return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
+	    }
+
+	} // distribution TT
+
+} // distribution T
 
 static inline forall( dtype T | sized(T) ) {