Index: boot/generic/src/balloc.c
===================================================================
--- boot/generic/src/balloc.c	(revision 8ddaaacd4f1ffc7cd429e863b42a92bfe0fbf899)
+++ boot/generic/src/balloc.c	(revision a1a81f698d5d7a69659be156314cb47101fde090)
@@ -49,15 +49,15 @@
 	if (alignment == 0)
 		return NULL;
-	
+
 	/* Enforce minimal alignment. */
 	alignment = ALIGN_UP(alignment, 4);
-	
+
 	uintptr_t addr = phys_base + ALIGN_UP(ballocs->size, alignment);
-	
+
 	if (ALIGN_UP(ballocs->size, alignment) + size >= max_size)
 		return NULL;
-	
+
 	ballocs->size = ALIGN_UP(ballocs->size, alignment) + size;
-	
+
 	return (void *) addr;
 }
Index: boot/generic/src/inflate.c
===================================================================
--- boot/generic/src/inflate.c	(revision 8ddaaacd4f1ffc7cd429e863b42a92bfe0fbf899)
+++ boot/generic/src/inflate.c	(revision a1a81f698d5d7a69659be156314cb47101fde090)
@@ -103,12 +103,12 @@
 	size_t destlen;   /**< Output buffer size */
 	size_t destcnt;   /**< Position in the output buffer */
-	
+
 	uint8_t *src;     /**< Input buffer */
 	size_t srclen;    /**< Input buffer size */
 	size_t srccnt;    /**< Position in the input buffer */
-	
+
 	uint16_t bitbuf;  /**< Bit buffer */
 	size_t bitlen;    /**< Number of bits in the bit buffer */
-	
+
 	bool overrun;     /**< Overrun condition */
 } inflate_state_t;
@@ -240,5 +240,5 @@
 	/* Bit accumulator for at least 20 bits */
 	uint32_t val = state->bitbuf;
-	
+
 	while (state->bitlen < cnt) {
 		if (state->srccnt == state->srclen) {
@@ -246,5 +246,5 @@
 			return 0;
 		}
-		
+
 		/* Load 8 more bits */
 		val |= ((uint32_t) state->src[state->srccnt]) << state->bitlen;
@@ -252,9 +252,9 @@
 		state->bitlen += 8;
 	}
-	
+
 	/* Update bits in the buffer */
 	state->bitbuf = (uint16_t) (val >> cnt);
 	state->bitlen -= cnt;
-	
+
 	return ((uint16_t) (val & ((1 << cnt) - 1)));
 }
@@ -275,32 +275,32 @@
 	state->bitbuf = 0;
 	state->bitlen = 0;
-	
+
 	if (state->srccnt + 4 > state->srclen)
 		return ELIMIT;
-	
+
 	uint16_t len =
 	    state->src[state->srccnt] | (state->src[state->srccnt + 1] << 8);
 	uint16_t len_compl =
 	    state->src[state->srccnt + 2] | (state->src[state->srccnt + 3] << 8);
-	
+
 	/* Check block length and its complement */
 	if (((int16_t) len) != ~((int16_t) len_compl))
 		return EINVAL;
-	
+
 	state->srccnt += 4;
-	
+
 	/* Check input buffer size */
 	if (state->srccnt + len > state->srclen)
 		return ELIMIT;
-	
+
 	/* Check output buffer size */
 	if (state->destcnt + len > state->destlen)
 		return ENOMEM;
-	
+
 	/* Copy data */
 	memcpy(state->dest + state->destcnt, state->src + state->srccnt, len);
 	state->srccnt += len;
 	state->destcnt += len;
-	
+
 	return EOK;
 }
@@ -323,5 +323,5 @@
 	size_t index = 0;  /* Index of the first code of the given length
 	                      in the symbol table */
-	
+
 	size_t len;  /* Current number of bits in the code */
 	for (len = 1; len <= MAX_HUFFMAN_BIT; len++) {
@@ -329,5 +329,5 @@
 		code |= get_bits(state, 1);
 		CHECK_OVERRUN(*state);
-		
+
 		uint16_t count = huffman->count[len];
 		if (code < first + count) {
@@ -336,5 +336,5 @@
 			return EOK;
 		}
-		
+
 		/* Update for next length */
 		index += count;
@@ -343,5 +343,5 @@
 		code <<= 1;
 	}
-	
+
 	return EINVAL;
 }
@@ -364,15 +364,15 @@
 	for (len = 0; len <= MAX_HUFFMAN_BIT; len++)
 		huffman->count[len] = 0;
-	
+
 	/* We assume that the lengths are within bounds */
 	size_t symbol;
 	for (symbol = 0; symbol < n; symbol++)
 		huffman->count[length[symbol]]++;
-	
+
 	if (huffman->count[0] == n) {
 		/* The code is complete, but decoding will fail */
 		return 0;
 	}
-	
+
 	/* Check for an over-subscribed or incomplete set of lengths */
 	int16_t left = 1;
@@ -385,12 +385,12 @@
 		}
 	}
-	
+
 	/* Generate offsets into symbol table */
 	uint16_t offs[MAX_HUFFMAN_BIT + 1];
-	
+
 	offs[1] = 0;
 	for (len = 1; len < MAX_HUFFMAN_BIT; len++)
 		offs[len + 1] = offs[len] + huffman->count[len];
-	
+
 	for (symbol = 0; symbol < n; symbol++) {
 		if (length[symbol] != 0) {
@@ -399,5 +399,5 @@
 		}
 	}
-	
+
 	return left;
 }
@@ -422,5 +422,5 @@
 {
 	uint16_t symbol;
-	
+
 	do {
 		int err = huffman_decode(state, len_code, &symbol);
@@ -429,10 +429,10 @@
 			return err;
 		}
-		
+
 		if (symbol < 256) {
 			/* Write out literal */
 			if (state->destcnt == state->destlen)
 				return ENOMEM;
-			
+
 			state->dest[state->destcnt] = (uint8_t) symbol;
 			state->destcnt++;
@@ -442,20 +442,20 @@
 			if (symbol >= 29)
 				return EINVAL;
-			
+
 			size_t len = lens[symbol] + get_bits(state, lens_ext[symbol]);
 			CHECK_OVERRUN(*state);
-			
+
 			/* Get distance */
 			err = huffman_decode(state, dist_code, &symbol);
 			if (err != EOK)
 				return err;
-			
+
 			size_t dist = dists[symbol] + get_bits(state, dists_ext[symbol]);
 			if (dist > state->destcnt)
 				return ENOENT;
-			
+
 			if (state->destcnt + len > state->destlen)
 				return ENOMEM;
-			
+
 			while (len > 0) {
 				/* Copy len bytes from distance bytes back */
@@ -467,5 +467,5 @@
 		}
 	} while (symbol != 256);
-	
+
 	return EOK;
 }
@@ -510,25 +510,25 @@
 	huffman_t dyn_len_code;
 	huffman_t dyn_dist_code;
-	
+
 	dyn_len_code.count = dyn_len_count;
 	dyn_len_code.symbol = dyn_len_symbol;
-	
+
 	dyn_dist_code.count = dyn_dist_count;
 	dyn_dist_code.symbol = dyn_dist_symbol;
-	
+
 	/* Get number of bits in each table */
 	uint16_t nlen = get_bits(state, 5) + 257;
 	CHECK_OVERRUN(*state);
-	
+
 	uint16_t ndist = get_bits(state, 5) + 1;
 	CHECK_OVERRUN(*state);
-	
+
 	uint16_t ncode = get_bits(state, 4) + 4;
 	CHECK_OVERRUN(*state);
-	
+
 	if ((nlen > MAX_LITLEN) || (ndist > MAX_DIST)
 	    || (ncode > MAX_ORDER))
 		return EINVAL;
-	
+
 	/* Read code length code lengths */
 	uint16_t index;
@@ -537,14 +537,14 @@
 		CHECK_OVERRUN(*state);
 	}
-	
+
 	/* Set missing lengths to zero */
 	for (index = ncode; index < MAX_ORDER; index++)
 		length[order[index]] = 0;
-	
+
 	/* Build Huffman code */
 	int16_t rc = huffman_construct(&dyn_len_code, length, MAX_ORDER);
 	if (rc != 0)
 		return EINVAL;
-	
+
 	/* Read length/literal and distance code length tables */
 	index = 0;
@@ -554,5 +554,5 @@
 		if (err != EOK)
 			return EOK;
-		
+
 		if (symbol < 16) {
 			length[index] = symbol;
@@ -560,9 +560,9 @@
 		} else {
 			uint16_t len = 0;
-			
+
 			if (symbol == 16) {
 				if (index == 0)
 					return EINVAL;
-				
+
 				len = length[index - 1];
 				symbol = get_bits(state, 2) + 3;
@@ -575,8 +575,8 @@
 				CHECK_OVERRUN(*state);
 			}
-			
+
 			if (index + symbol > nlen + ndist)
 				return EINVAL;
-			
+
 			while (symbol > 0) {
 				length[index] = len;
@@ -586,19 +586,19 @@
 		}
 	}
-	
+
 	/* Check for end-of-block code */
 	if (length[256] == 0)
 		return EINVAL;
-	
+
 	/* Build Huffman tables for literal/length codes */
 	rc = huffman_construct(&dyn_len_code, length, nlen);
 	if ((rc < 0) || ((rc > 0) && (dyn_len_code.count[0] + 1 != nlen)))
 		return EINVAL;
-	
+
 	/* Build Huffman tables for distance codes */
 	rc = huffman_construct(&dyn_dist_code, length + nlen, ndist);
 	if ((rc < 0) || ((rc > 0) && (dyn_dist_code.count[0] + 1 != ndist)))
 		return EINVAL;
-	
+
 	return inflate_codes(state, &dyn_len_code, &dyn_dist_code);
 }
@@ -622,30 +622,30 @@
 	/* Initialize the state */
 	inflate_state_t state;
-	
+
 	state.dest = (uint8_t *) dest;
 	state.destlen = destlen;
 	state.destcnt = 0;
-	
+
 	state.src = (uint8_t *) src;
 	state.srclen = srclen;
 	state.srccnt = 0;
-	
+
 	state.bitbuf = 0;
 	state.bitlen = 0;
-	
+
 	state.overrun = false;
-	
+
 	uint16_t last;
 	int ret = 0;
-	
+
 	do {
 		/* Last block is indicated by a non-zero bit */
 		last = get_bits(&state, 1);
 		CHECK_OVERRUN(state);
-		
+
 		/* Block type */
 		uint16_t type = get_bits(&state, 2);
 		CHECK_OVERRUN(state);
-		
+
 		switch (type) {
 		case 0:
@@ -662,5 +662,5 @@
 		}
 	} while ((!last) && (ret == 0));
-	
+
 	return ret;
 }
Index: boot/generic/src/memstr.c
===================================================================
--- boot/generic/src/memstr.c	(revision 8ddaaacd4f1ffc7cd429e863b42a92bfe0fbf899)
+++ boot/generic/src/memstr.c	(revision a1a81f698d5d7a69659be156314cb47101fde090)
@@ -46,8 +46,8 @@
 	uint8_t *dp = (uint8_t *) dst;
 	const uint8_t *sp = (uint8_t *) src;
-	
+
 	while (cnt-- != 0)
 		*dp++ = *sp++;
-	
+
 	return dst;
 }
@@ -67,8 +67,8 @@
 {
 	uint8_t *dp = (uint8_t *) dst;
-	
+
 	while (cnt-- != 0)
 		*dp++ = val;
-	
+
 	return dst;
 }
@@ -91,12 +91,12 @@
 	if (src == dst)
 		return dst;
-	
+
 	/* Non-overlapping? */
 	if ((dst >= src + cnt) || (src >= dst + cnt))
 		return memcpy(dst, src, cnt);
-	
+
 	uint8_t *dp;
 	const uint8_t *sp;
-	
+
 	/* Which direction? */
 	if (src > dst) {
@@ -104,5 +104,5 @@
 		dp = dst;
 		sp = src;
-		
+
 		while (cnt-- != 0)
 			*dp++ = *sp++;
@@ -111,9 +111,9 @@
 		dp = dst + (cnt - 1);
 		sp = src + (cnt - 1);
-		
+
 		while (cnt-- != 0)
 			*dp-- = *sp--;
 	}
-	
+
 	return dst;
 }
Index: boot/generic/src/printf.c
===================================================================
--- boot/generic/src/printf.c	(revision 8ddaaacd4f1ffc7cd429e863b42a92bfe0fbf899)
+++ boot/generic/src/printf.c	(revision a1a81f698d5d7a69659be156314cb47101fde090)
@@ -37,11 +37,11 @@
 	int ret;
 	va_list args;
-	
+
 	va_start(args, fmt);
-	
+
 	ret = vprintf(fmt, args);
-	
+
 	va_end(args);
-	
+
 	return ret;
 }
Index: boot/generic/src/printf_core.c
===================================================================
--- boot/generic/src/printf_core.c	(revision 8ddaaacd4f1ffc7cd429e863b42a92bfe0fbf899)
+++ boot/generic/src/printf_core.c	(revision a1a81f698d5d7a69659be156314cb47101fde090)
@@ -138,5 +138,5 @@
 	if (str == NULL)
 		return printf_putnchars(nullstr, str_size(nullstr), ps);
-	
+
 	return ps->str_write((void *) str, str_size(str), ps->data);
 }
@@ -154,5 +154,5 @@
 	if (!ascii_check(ch))
 		return ps->str_write((void *) &invalch, 1, ps->data);
-	
+
 	return ps->str_write(&ch, 1, ps->data);
 }
@@ -180,8 +180,8 @@
 		}
 	}
-	
+
 	if (printf_putchar(ch, ps) > 0)
 		counter++;
-	
+
 	while (--width > 0) {
 		/*
@@ -192,5 +192,5 @@
 			counter++;
 	}
-	
+
 	return (int) (counter);
 }
@@ -210,10 +210,10 @@
 	if (str == NULL)
 		return printf_putstr(nullstr, ps);
-	
+
 	/* Print leading spaces. */
 	size_t strw = str_length(str);
 	if ((precision == 0) || (precision > strw))
 		precision = strw;
-	
+
 	/* Left padding */
 	size_t counter = 0;
@@ -225,5 +225,5 @@
 		}
 	}
-	
+
 	/* Part of @a str fitting into the alloted space. */
 	int retval;
@@ -231,7 +231,7 @@
 	if ((retval = printf_putnchars(str, size, ps)) < 0)
 		return -counter;
-	
+
 	counter += retval;
-	
+
 	/* Right padding */
 	while (width-- > 0) {
@@ -264,14 +264,14 @@
 	else
 		digits = digits_small;
-	
+
 	char data[PRINT_NUMBER_BUFFER_SIZE];
 	char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];
-	
+
 	/* Size of number with all prefixes and signs */
 	int size = 0;
-	
+
 	/* Put zero at end of string */
 	*ptr-- = 0;
-	
+
 	if (num == 0) {
 		*ptr-- = '0';
@@ -283,8 +283,8 @@
 		} while (num /= base);
 	}
-	
+
 	/* Size of plain number */
 	int number_size = size;
-	
+
 	/*
 	 * Collect the sum of all prefixes/signs/etc. to calculate padding and
@@ -305,5 +305,5 @@
 		}
 	}
-	
+
 	char sgn = 0;
 	if (flags & __PRINTF_FLAG_SIGNED) {
@@ -319,8 +319,8 @@
 		}
 	}
-	
+
 	if (flags & __PRINTF_FLAG_LEFTALIGNED)
 		flags &= ~__PRINTF_FLAG_ZEROPADDED;
-	
+
 	/*
 	 * If the number is left-aligned or precision is specified then
@@ -331,5 +331,5 @@
 			precision = width - size + number_size;
 	}
-	
+
 	/* Print leading spaces */
 	if (number_size > precision) {
@@ -337,8 +337,8 @@
 		precision = number_size;
 	}
-	
+
 	width -= precision + size - number_size;
 	size_t counter = 0;
-	
+
 	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
 		while (width-- > 0) {
@@ -347,5 +347,5 @@
 		}
 	}
-	
+
 	/* Print sign */
 	if (sgn) {
@@ -353,5 +353,5 @@
 			counter++;
 	}
-	
+
 	/* Print prefix */
 	if (flags & __PRINTF_FLAG_PREFIX) {
@@ -386,5 +386,5 @@
 		}
 	}
-	
+
 	/* Print leading zeroes */
 	precision -= number_size;
@@ -393,17 +393,17 @@
 			counter++;
 	}
-	
+
 	/* Print the number itself */
 	int retval;
 	if ((retval = printf_putstr(++ptr, ps)) > 0)
 		counter += retval;
-	
+
 	/* Print trailing spaces */
-	
+
 	while (width-- > 0) {
 		if (printf_putchar(' ', ps) == 1)
 			counter++;
 	}
-	
+
 	return ((int) counter);
 }
@@ -497,15 +497,15 @@
 	size_t nxt = 0;  /* Index of the next character from fmt */
 	size_t j = 0;    /* Index to the first not printed nonformating character */
-	
+
 	size_t counter = 0;   /* Number of characters printed */
 	int retval;           /* Return values from nested functions */
-	
+
 	while (true) {
 		i = nxt;
 		wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-		
+
 		if (uc == 0)
 			break;
-		
+
 		/* Control character */
 		if (uc == '%') {
@@ -519,11 +519,11 @@
 				counter += retval;
 			}
-			
+
 			j = i;
-			
+
 			/* Parse modifiers */
 			uint32_t flags = 0;
 			bool end = false;
-			
+
 			do {
 				i = nxt;
@@ -549,5 +549,5 @@
 				};
 			} while (!end);
-			
+
 			/* Width & '*' operator */
 			int width = 0;
@@ -556,5 +556,5 @@
 					width *= 10;
 					width += uc - '0';
-					
+
 					i = nxt;
 					uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
@@ -575,5 +575,5 @@
 				}
 			}
-			
+
 			/* Precision and '*' operator */
 			int precision = 0;
@@ -585,5 +585,5 @@
 						precision *= 10;
 						precision += uc - '0';
-						
+
 						i = nxt;
 						uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
@@ -604,7 +604,7 @@
 				}
 			}
-			
+
 			qualifier_t qualifier;
-			
+
 			switch (uc) {
 			case 't':
@@ -653,7 +653,7 @@
 				qualifier = PrintfQualifierInt;
 			}
-			
+
 			unsigned int base = 10;
-			
+
 			switch (uc) {
 			/*
@@ -662,10 +662,10 @@
 			case 's':
 				retval = print_str(va_arg(ap, char *), width, precision, flags, ps);
-				
+
 				if (retval < 0) {
 					counter = -counter;
 					goto out;
 				}
-				
+
 				counter += retval;
 				j = nxt;
@@ -673,14 +673,14 @@
 			case 'c':
 				retval = print_char(va_arg(ap, unsigned int), width, flags, ps);
-				
+
 				if (retval < 0) {
 					counter = -counter;
 					goto out;
 				};
-				
+
 				counter += retval;
 				j = nxt;
 				goto next_char;
-			
+
 			/*
 			 * Integer values
@@ -714,10 +714,10 @@
 				base = 16;
 				break;
-			
+
 			/* Percentile itself */
 			case '%':
 				j = i;
 				goto next_char;
-			
+
 			/*
 			 * Bad formatting.
@@ -730,9 +730,9 @@
 				goto next_char;
 			}
-			
+
 			/* Print integers */
 			size_t size;
 			uint64_t number;
-			
+
 			switch (qualifier) {
 			case PrintfQualifierByte:
@@ -774,5 +774,5 @@
 				goto out;
 			}
-			
+
 			if ((retval = print_number(number, width, precision,
 			    base, flags, ps)) < 0) {
@@ -780,5 +780,5 @@
 				goto out;
 			}
-			
+
 			counter += retval;
 			j = nxt;
@@ -787,5 +787,5 @@
 		;
 	}
-	
+
 	if (i > j) {
 		if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
@@ -796,5 +796,5 @@
 		counter += retval;
 	}
-	
+
 out:
 	return ((int) counter);
Index: boot/generic/src/str.c
===================================================================
--- boot/generic/src/str.c	(revision 8ddaaacd4f1ffc7cd429e863b42a92bfe0fbf899)
+++ boot/generic/src/str.c	(revision a1a81f698d5d7a69659be156314cb47101fde090)
@@ -141,13 +141,13 @@
 	if (*offset + 1 > size)
 		return 0;
-	
+
 	/* First byte read from string */
 	uint8_t b0 = (uint8_t) str[(*offset)++];
-	
+
 	/* Determine code length */
-	
+
 	unsigned int b0_bits;  /* Data bits in first byte */
 	unsigned int cbytes;   /* Number of continuation bytes */
-	
+
 	if ((b0 & 0x80) == 0) {
 		/* 0xxxxxxx (Plain ASCII) */
@@ -170,23 +170,23 @@
 		return U_SPECIAL;
 	}
-	
+
 	if (*offset + cbytes > size)
 		return U_SPECIAL;
-	
+
 	wchar_t ch = b0 & LO_MASK_8(b0_bits);
-	
+
 	/* Decode continuation bytes */
 	while (cbytes > 0) {
 		uint8_t b = (uint8_t) str[(*offset)++];
-		
+
 		/* Must be 10xxxxxx */
 		if ((b & 0xc0) != 0x80)
 			return U_SPECIAL;
-		
+
 		/* Shift data bits to ch */
 		ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
 		cbytes--;
 	}
-	
+
 	return ch;
 }
@@ -211,17 +211,17 @@
 	if (*offset >= size)
 		return EOVERFLOW;
-	
+
 	if (!chr_check(ch))
 		return EINVAL;
-	
+
 	/* Unsigned version of ch (bit operations should only be done
 	   on unsigned types). */
 	uint32_t cc = (uint32_t) ch;
-	
+
 	/* Determine how many continuation bytes are needed */
-	
+
 	unsigned int b0_bits;  /* Data bits in first byte */
 	unsigned int cbytes;   /* Number of continuation bytes */
-	
+
 	if ((cc & ~LO_MASK_32(7)) == 0) {
 		b0_bits = 7;
@@ -240,9 +240,9 @@
 		return EINVAL;
 	}
-	
+
 	/* Check for available space in buffer */
 	if (*offset + cbytes >= size)
 		return EOVERFLOW;
-	
+
 	/* Encode continuation bytes */
 	unsigned int i;
@@ -251,11 +251,11 @@
 		cc = cc >> CONT_BITS;
 	}
-	
+
 	/* Encode first byte */
 	str[*offset] = (cc & LO_MASK_32(b0_bits)) | HI_MASK_8(8 - b0_bits - 1);
-	
+
 	/* Advance offset */
 	*offset += cbytes + 1;
-	
+
 	return EOK;
 }
@@ -274,8 +274,8 @@
 {
 	size_t size = 0;
-	
+
 	while (*str++ != 0)
 		size++;
-	
+
 	return size;
 }
@@ -298,12 +298,12 @@
 	size_t len = 0;
 	size_t offset = 0;
-	
+
 	while (len < max_len) {
 		if (str_decode(str, &offset, STR_NO_LIMIT) == 0)
 			break;
-		
+
 		len++;
 	}
-	
+
 	return offset;
 }
@@ -320,8 +320,8 @@
 	size_t len = 0;
 	size_t offset = 0;
-	
+
 	while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
 		len++;
-	
+
 	return len;
 }
@@ -336,5 +336,5 @@
 	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
 		return true;
-	
+
 	return false;
 }
@@ -349,5 +349,5 @@
 	if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
 		return true;
-	
+
 	return false;
 }
@@ -375,22 +375,22 @@
 	wchar_t c1 = 0;
 	wchar_t c2 = 0;
-	
+
 	size_t off1 = 0;
 	size_t off2 = 0;
-	
+
 	while (true) {
 		c1 = str_decode(s1, &off1, STR_NO_LIMIT);
 		c2 = str_decode(s2, &off2, STR_NO_LIMIT);
-		
+
 		if (c1 < c2)
 			return -1;
-		
+
 		if (c1 > c2)
 			return 1;
-		
+
 		if ((c1 == 0) || (c2 == 0))
 			break;
 	}
-	
+
 	return 0;
 }
@@ -412,5 +412,5 @@
 	size_t src_off = 0;
 	size_t dest_off = 0;
-	
+
 	wchar_t ch;
 	while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
@@ -418,5 +418,5 @@
 			break;
 	}
-	
+
 	dest[dest_off] = '\0';
 }
Index: boot/generic/src/vprintf.c
===================================================================
--- boot/generic/src/vprintf.c	(revision 8ddaaacd4f1ffc7cd429e863b42a92bfe0fbf899)
+++ boot/generic/src/vprintf.c	(revision a1a81f698d5d7a69659be156314cb47101fde090)
@@ -40,10 +40,10 @@
 	size_t offset = 0;
 	size_t chars = 0;
-	
+
 	while (offset < size) {
 		putchar(str_decode(str, &offset, size));
 		chars++;
 	}
-	
+
 	return chars;
 }
@@ -54,10 +54,10 @@
 	size_t chars = 0;
 	wchar_t uc;
-	
+
 	while ((uc = str_decode(str, &offset, STR_NO_LIMIT)) != 0) {
 		putchar(uc);
 		chars++;
 	}
-	
+
 	return chars;
 }
@@ -69,7 +69,7 @@
 		NULL
 	};
-	
+
 	int ret = printf_core(fmt, &ps, ap);
-	
+
 	return ret;
 }