Index: uspace/lib/mbr/libmbr.c
===================================================================
--- uspace/lib/mbr/libmbr.c	(revision 8f6c778597143e8b7a55779be0e07007930e4f3c)
+++ uspace/lib/mbr/libmbr.c	(revision 700f89ec90c0d82b5e2a3bfa99e10cdac6785fec)
@@ -53,5 +53,9 @@
 static int check_preceeds(mbr_part_t * preceeder, mbr_part_t * precedee);
 
-static void debug_print(unsigned char * data, size_t bytes);
+/** Allocate memory for mbr_t */
+mbr_t * mbr_alloc_mbr()
+{
+	return alloc_br();
+}
 
 /** Read MBR from specific device
@@ -71,4 +75,5 @@
 	rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
 	if (rc != EOK) {
+		free(mbr);
 		return NULL;
 	}
@@ -76,4 +81,5 @@
 	rc = block_read_direct(dev_handle, 0, 1, &(mbr->raw_data));
 	if (rc != EOK) {
+		free(mbr);
 		block_fini(dev_handle);
 		return NULL;
@@ -83,5 +89,4 @@
 
 	mbr->device = dev_handle;
-	//mbr->partitions = NULL;
 
 	return mbr;
@@ -93,5 +98,5 @@
  * 							from the device in 'mbr')
  *
- * @return				0 on success, -1 on block_init error, -2 on write error
+ * @return				0 on success, otherwise libblock error code
  */
 int mbr_write_mbr(mbr_t * mbr, service_id_t dev_handle)
@@ -149,5 +154,4 @@
 			continue;
 		
-		//p = malloc(sizeof(mbr_part_t));
 		p = mbr_alloc_partition();
 		if (p == NULL) {
@@ -156,5 +160,5 @@
 			return NULL;
 		}
-		//list_append(&(p->link), &(parts->list));
+		
 		rc_ext = decode_part(&(mbr->raw_data.pte[i]), p, 0);
 		mbr_set_flag(p, ST_LOGIC, false);
@@ -179,6 +183,4 @@
 	}
 	
-	//DEBUG:
-	//debug_print((unsigned char *) list_get_instance(list_last(&(parts->list)), mbr_part_t, link)->ebr, 512);
 	return parts;
 }
@@ -193,5 +195,4 @@
 int mbr_write_partitions(mbr_partitions_t * parts, mbr_t * mbr, service_id_t dev_handle)
 {
-	//bool logical = false;
 	int i = 0;
 	int rc;
@@ -200,43 +201,9 @@
 					: list_get_instance(parts->l_extended, mbr_part_t, link);
 	
-	//br_block_t * last_ebr = NULL;
-	//link_t * it;
-	
-	DEBUG_PRINT_3(LIBMBR_NAME "Writing partitions: n_primary: %u, n_logical:%u, l_extended:%p", parts->n_primary, parts->n_logical, parts->l_extended);
-	
 	rc = block_init(EXCHANGE_ATOMIC, dev_handle, 512);
 	if (rc != EOK) {
-		DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
+		printf(LIBMBR_NAME ": Error while initializing libblock: %d - %s.\n", rc, str_error(rc));
 		return rc;
 	}
-	/*
-	// Encoding primary partitions
-	for (i = 0; i < parts->n_primary; i++) {
-		encode_part(p, &(mbr->raw_data.pte[i]), 0);
-	}
-
-	// Writing MBR
-	rc = block_write_direct(dev_handle, 0, 1, &(mbr->raw_data));
-	if (rc != EOK) {
-		DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
-		goto end;
-	}
-
-	uint32_t base = ext->start_addr;
-	uint32_t addr = base;
-
-	// Encoding and writing logical partitions
-	mbr_part_foreach(parts, p) {
-		if (p->ebr == NULL) {
-			p->ebr = alloc_br();
-			if (p->ebr == NULL)
-			{
-				rc = ENOMEM;
-				goto end;
-			}
-		}
-
-
-	}*/
 	
 	link_t * l = parts->list.head.next;
@@ -252,18 +219,19 @@
 	rc = block_write_direct(dev_handle, 0, 1, &(mbr->raw_data));
 	if (rc != EOK) {
-		DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
+		printf(LIBMBR_NAME ": Error while writing MBR : %d - %s.\n", rc, str_error(rc));
 		goto end;
 	}
 	
 	if (ext == NULL)
-		goto no_extended;
-	
-	//DEBUG:
-	//debug_print((unsigned char *) list_get_instance(list_last(&(parts->list)), mbr_part_t, link)->ebr, 512);
+		goto end;
+	
 	uint32_t base = ext->start_addr;
-	//uint32_t addr = base;
-	//uint32_t prev_addr;
-	//mbr_part_t * tmp;
 	mbr_part_t * prev_p;
+	
+	/* Note for future changes: Some thought has been put into design
+	 * and implementation. If you don't have to change it, don't. Other
+	 * designs have been tried, this came out as the least horror with
+	 * as much power over it as you can get. Thanks. */
+	
 	// Encoding and writing first logical partition
 	if (l != &(parts->list.head)) {
@@ -271,27 +239,19 @@
 		p->ebr_addr = base;
 		encode_part(p, &(p->ebr->pte[0]), base, false);
-		
-		/*if (l->next == &(parts->list.head))
-			encode_part(NULL, &(p->ebr->pte[1]), base, false);
-		else {
-			tmp = list_get_instance(l->next, mbr_part_t, link);
-			//debug_print((unsigned char*) p->ebr, 512);
-			printf("DEBUG: base: %u, tmp: start: %u, end: %u\n", base, tmp->start_addr, tmp->start_addr + tmp->length);
-			//encode_part(tmp, &(p->ebr->pte[1]), base);
-			encode_part(tmp, &(p->ebr->pte[1]), base, true);
-			debug_print(((unsigned char*) p->ebr) + 446, 32);
-		}
-		
-		rc = block_write_direct(dev_handle, base, 1, p->ebr);
+		l = l->next;
+	} else {
+		/* If there was an extended but no logical, we should overwrite
+		 * the space where the first logical's EBR would have been. There
+		 * might be some garbage from the past. */
+		br_block_t * tmp = alloc_br();
+		rc = block_write_direct(dev_handle, base, 1, tmp);
 		if (rc != EOK) {
-			DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
+			printf(LIBMBR_NAME ": Error while writing EBR: %d - %s.\n", rc, str_error(rc));
 			goto end;
-		}*/
-		
-		l = l->next;
-	} else
-		goto no_logical;
-	
-	//prev_addr = base;
+		}
+		free(tmp);
+		goto end;
+	}
+	
 	prev_p = p;
 	
@@ -314,16 +274,9 @@
 		
 		encode_part(p, &(p->ebr->pte[0]), p->ebr_addr, false);
-		debug_print(((unsigned char*) p->ebr) + 446, 32);
 		encode_part(p, &(prev_p->ebr->pte[1]), base, true);
-		debug_print(((unsigned char*) prev_p->ebr) + 446, 32);
-		/*if (l->next == &(parts->list.head))
-			encode_part(NULL, &(p->ebr->pte[1]), base, false);
-		else
-			encode_part(list_get_instance(l->next, mbr_part_t, link), &(p->ebr->pte[1]), base, true);
-		*/
 		
 		rc = block_write_direct(dev_handle, prev_p->ebr_addr, 1, prev_p->ebr);
 		if (rc != EOK) {
-			DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
+			printf(LIBMBR_NAME ": Error while writing EBR: %d - %s.\n", rc, str_error(rc));
 			goto end;
 		}
@@ -333,215 +286,11 @@
 	}
 	
+	// write the last EBR
 	encode_part(NULL, &(prev_p->ebr->pte[1]), 0, false);
 	rc = block_write_direct(dev_handle, prev_p->ebr_addr, 1, prev_p->ebr);
 	if (rc != EOK) {
-		DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
+		printf(LIBMBR_NAME ": Error while writing EBR: %d - %s.\n", rc, str_error(rc));
 		goto end;
 	}
-	
-no_logical:
-no_extended:
-	
-	/*if (ext == NULL)
-		goto no_extended;
-
-	uint32_t base = ext->start_addr;
-	uint32_t addr;// = base;
-	uint32_t prev_addr;
-	mbr_part_t * prev_part = NULL;
-
-	list_foreach(parts->list, iter) {
-		p = list_get_instance(iter, mbr_part_t, link);
-		if (mbr_get_flag(p, ST_LOGIC)) {
-			// writing logical partition
-			logical = true;
-
-			if (p->ebr == NULL) {
-				p->ebr = alloc_br();
-				if (p->ebr == NULL)
-				{
-					rc = ENOMEM;
-					goto end;
-				}
-			}
-
-			if (prev_part != NULL) {
-				// addr is the address of EBR
-				addr = p->start_addr - base;
-				// base-1 means start_lba+1
-				encode_part(p, &(p->ebr->pte[0]), addr - 1);
-				encode_part(p, &(prev_part->ebr->pte[1]), base);
-				rc = block_write_direct(dev_handle, prev_addr, 1, prev_part->ebr);
-				if (rc != EOK) {
-					DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
-					goto end;
-				}
-			} else {
-				// addr is the address of EBR
-				addr = base;
-				// base-1 means start_lba+1
-				// Fixed: mbr_add_partition now performs checks!nevim
-				encode_part(p, &(p->ebr->pte[0]), base);
-			}
-
-			//addr = p->start_addr;
-			prev_addr = addr;
-			prev_part = p;
-		} else {
-			// writing primary partition
-			if (i >= 4) {
-				rc = EINVAL;
-				goto end;
-			}
-
-			encode_part(p, &(mbr->raw_data.pte[i]), 0);
-
-			++i;
-		}
-	} //*/
-
-	/* If there was an extended but no logical, we should overwrite
-	 * the space where the first logical's EBR would have been. There
-	 * might be some garbage from the past.
-	 */
-	/*
-	last_ebr = prev_part->ebr;
-
-	if (!logical)
-	{
-		last_ebr = alloc_br();
-		if (last_ebr == NULL) {
-			rc = ENOMEM;
-			goto end;
-		}
-
-		last_ebr->pte[0].ptype = PT_UNUSED;
-	}
-
-
-	encode_part(NULL, &(last_ebr->pte[1]), 0);
-	rc = block_write_direct(dev_handle, addr, 1, last_ebr);
-
-	if (!logical)
-	{
-		free(last_ebr);
-	}
-	*/
-	/*
-	if (rc != EOK) {
-		DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
-		goto end;
-	}
-
-	goto skip;
-
-no_extended:
-	*/
-	/*list_foreach(parts->list, it) {
-		p = list_get_instance(it, mbr_part_t, link);
-		if (mbr_get_flag(p, ST_LOGIC)) {
-			// extended does not exist, fail
-			return EINVAL;
-		} else {
-			// writing primary partition
-			if (i >= 4)
-				return EINVAL;
-
-			encode_part(p, &(mbr->raw_data.pte[i]), 0);
-
-			++i;
-		}
-	}*/
-	/*
-	it = parts->list.head.next;
-	for (i = 0; i < N_PRIMARY; i++) {
-		if (it != &parts->list.head) {
-			p = list_get_instance(it, mbr_part_t, link);
-			if (mbr_get_flag(p, ST_LOGIC)) {
-				// extended does not exist, fail
-				return EINVAL;
-			} else {
-				// writing primary partition
-				if (i >= 4)
-					return EINVAL;
-
-				encode_part(p, &(mbr->raw_data.pte[i]), 0);
-
-			}
-
-			it = it->next;
-		} else {
-			encode_part(NULL, &(mbr->raw_data.pte[i]), 0);
-		}
-	}
-
-
-skip:
-	rc = block_write_direct(dev_handle, 0, 1, &(mbr->raw_data));
-	if (rc != EOK) {
-		DEBUG_PRINT_2(LIBMBR_NAME ": Error (%d): %s.\n", rc, str_error(rc));
-		goto end;
-	}
-	*/
-
-	/*
-	for (i = 0; i < N_PRIMARY; ++i) {
-		encode_part(&(p->partition), &(mbr->raw_data.pte[i]), 0);
-		if (p->type == PT_EXTENDED)
-			ext = p;
-
-		//p = list_get_instance(p->link.next, mbr_partitions_t, link);
-		p = p->next;
-	}
-
-	rc = block_write_direct(dev_handle, 0, 1, &(mbr->raw_data));
-	if (rc != EOK) {
-		block_fini(dev_handle);
-		return rc;
-	}
-
-	//writing logical partitions
-
-	if (p == NULL && ext != NULL) {
-		//we need an empty EBR to rewrite the old EBR on disk, if we need to delete it
-		br_block_t * temp_ebr = alloc_br();
-		if (temp_ebr == NULL) {
-			block_fini(dev_handle);
-			return ENOMEM;
-		}
-
-		temp_ebr->pte[0].ptype = PT_UNUSED;
-		encode_part(NULL, &(temp_ebr->pte[1]), 0);
-		rc = block_write_direct(dev_handle, ext->start_addr, 1, temp_ebr);
-		free(temp_ebr);
-		block_fini(dev_handle);
-		return rc;
-	}
-
-	if (p != NULL && ext == NULL) {
-		block_fini(dev_handle);
-		//no extended but one or more logical? EINVAL to the rescue!
-		return EINVAL;
-	}
-
-	aoff64_t addr = ext->start_addr;
-
-	while (p != NULL) {
-		if (p->type == PT_UNUSED) {
-			p = p->next;
-			continue;
-		}
-		//encode_part(p, &(p->ebr->pte[0]), p->start_addr - 63 * 512);
-		encode_part(p, &(p->ebr->pte[0]), addr);
-		encode_part(p->next, &(p->ebr->pte[1]), ext->start_addr);
-
-		rc = block_write_direct(dev_handle, p->start_addr, 1, p->ebr);
-		if (rc != EOK) {
-			block_fini(dev_handle);
-			return rc;
-		}
-		addr = p->start_addr;
-		p = p->next;
-	}*/
 	
 	rc = EOK;
@@ -560,4 +309,5 @@
 		return NULL;
 	}
+	
 	link_initialize(&(p->link));
 	p->ebr = NULL;
@@ -571,4 +321,5 @@
 }
 
+/** mbr_partitions_t constructor */
 mbr_partitions_t * mbr_alloc_partitions(void)
 {
@@ -579,5 +330,4 @@
 
 	list_initialize(&(parts->list));
-
 	parts->n_primary = 0;
 	parts->n_logical = 0;
@@ -589,18 +339,23 @@
 /** Add partition
  * 	Performs checks, sorts the list.
- */
-int mbr_add_partition(mbr_partitions_t * parts, mbr_part_t * p)
+ * 
+ * @param parts			partition list to add to
+ * @param p				partition to add
+ * 
+ * @return				ERR_OK (0) on success, other MBR_ERR_VAL otherwise
+ */
+MBR_ERR_VAL mbr_add_partition(mbr_partitions_t * parts, mbr_part_t * p)
 {
 	if (mbr_get_flag(p, ST_LOGIC)) { // adding logical part
-		if (parts->l_extended == NULL) {
+		// is there any extended partition?
+		if (parts->l_extended == NULL)
 			return ERR_NO_EXTENDED;
-		}
+		
+		// is the logical partition inside the extended one?
 		mbr_part_t * ext = list_get_instance(parts->l_extended, mbr_part_t, link);
-		if (!check_encaps(p, ext)) {
-			//printf("DEBUG: OOB: start: %u, end: %u\n", h->start_addr, h->start_addr + h->length);
-			//printf("DEBUG: OOB: start: %u, end: %u\n", p->start_addr, p->start_addr + p->length);
+		if (!check_encaps(p, ext))
 			return ERR_OUT_BOUNDS;
-		}
-
+		
+		// find a place for the new partition in a sorted linked list
 		mbr_part_t * last = list_get_instance(list_last(&(parts->list)), mbr_part_t, link);
 		mbr_part_t * iter;
@@ -608,9 +363,6 @@
 		mbr_part_foreach(parts, iter) {
 			if (mbr_get_flag(iter, ST_LOGIC)) {
-				if (check_overlap(p, iter)) {
-					//printf("DEBUG: overlap: start: %u, end: %u\n", iter->start_addr, iter->start_addr + iter->length);
-					//printf("DEBUG: overlap: start: %u, end: %u\n", p->start_addr, p->start_addr + p->length);
+				if (check_overlap(p, iter)) 
 					return ERR_OVERLAP;
-				}
 				if (check_preceeds(iter, p)) {
 					last = iter;
@@ -622,5 +374,4 @@
 		
 		// checking if there's at least one sector of space preceeding
-		
 		if (ebr_space < 1)
 			return ERR_NO_EBR;
@@ -628,9 +379,9 @@
 		// checking if there's at least one sector of space following (for following partitions's EBR)
 		if (last->link.next != &(parts->list.head)) {
-			if (list_get_instance(&(last->link.next), mbr_part_t, link)->start_addr <= p->start_addr + p->length + 1) {
+			if (list_get_instance(&(last->link.next), mbr_part_t, link)->start_addr <= p->start_addr + p->length + 1)
 				return ERR_NO_EBR;
-			}
-		}
-		
+		}
+		
+		// alloc EBR if it's not already there
 		if (p->ebr == NULL) {
 			p->ebr = alloc_br();
@@ -640,23 +391,23 @@
 		}
 		
-		//printf("DEBUG: last: start: %u\n", last->start_addr);
-		//list_prepend(&(p->link), &(parts->list));
+		// add it
 		list_insert_after(&(p->link), &(last->link));
 		parts->n_logical += 1;
-	} else {
-		// adding primary
+	} else { // adding primary
 		if (parts->n_primary == 4) {
 			return ERR_PRIMARY_FULL;
 		}
 		
-		// should we check if it's inside the drive's upper boundary?
+		// TODO: should we check if it's inside the drive's upper boundary?
 		if (p->start_addr == 0) {
 			return ERR_OUT_BOUNDS;
 		}
 		
+		// if it's extended, is there any other one?
 		if (p->type == PT_EXTENDED && parts->l_extended != NULL) {
 			return ERR_EXTENDED_PRESENT;
 		}
-
+		
+		// find a place and add it
 		if (list_empty(&(parts->list))) {
 			list_append(&(p->link), &(parts->list));
@@ -667,39 +418,67 @@
 					list_insert_before(&(p->link), &(iter->link));
 					break;
-				} else if (check_overlap(p, iter)) {
+				} else if (check_overlap(p, iter))
 					return ERR_OVERLAP;
-				}
 			}
-			if (iter == list_get_instance(&(parts->list.head.prev), mbr_part_t, link)) {
+			if (iter == list_get_instance(&(parts->list.head.prev), mbr_part_t, link))
 				list_append(&(p->link), &(parts->list));
+		}
+		parts->n_primary += 1;
+	}
+
+	return ERR_OK;
+}
+
+/** Remove partition
+ * 	Removes partition by index, indexed from zero. When removing extended
+ * partition, all logical partitions get removed as well.
+ * 
+ * @param parts			partition list to remove from
+ * @param idx			index of the partition to remove
+ * 
+ * @return				EOK on success, EINVAL if idx invalid
+ */
+int mbr_remove_partition(mbr_partitions_t * parts, size_t idx)
+{
+	link_t * l = list_nth(&(parts->list), idx);
+	if (l == NULL)
+		return EINVAL;
+	
+	mbr_part_t * p;
+	
+	/* TODO: if it is extended partition, should we also remove all logical?
+	 * If we don't, we break the consistency of the list. If we do,
+	 * the user will have to input them all over again. So yes. */
+	if (l == parts->l_extended) {
+		parts->l_extended = NULL;
+		
+		link_t * it = l->next;
+		link_t * next_it;
+		while (it != &(parts->list.head)) {
+			next_it = it->next;
+			
+			p = list_get_instance(it, mbr_part_t, link);
+			if (mbr_get_flag(p, ST_LOGIC)) {
+				list_remove(it);
+				parts->n_logical -= 1;
+				mbr_free_partition(p);
 			}
 			
-		}
-		parts->n_primary += 1;
-	}
-
-	return ERR_OK;
-}
-
-/** Remove partition */
-int mbr_remove_partition(mbr_partitions_t * parts, size_t idx)
-{
-	DEBUG_PRINT_1(LIBMBR_NAME "Removing partition: %zu\n", idx);
-	link_t * l = list_nth(&(parts->list), idx);
-	if (l == parts->l_extended) {
-		DEBUG_PRINT_0(LIBMBR_NAME "Removing extended partition.\n");
-		parts->l_extended = NULL;
-	}
+			it = next_it;
+		}
+		
+	}
+	
 	list_remove(l);
-	mbr_part_t * p = list_get_instance(l, mbr_part_t, link);
-	if (mbr_get_flag(p, ST_LOGIC)) {
+	
+	p = list_get_instance(l, mbr_part_t, link);
+	if (mbr_get_flag(p, ST_LOGIC))
 		parts->n_logical -= 1;
-	} else {
+	else
 		parts->n_primary -= 1;
-	}
-
-
+	
+	
 	mbr_free_partition(p);
-
+	
 	return EOK;
 }
@@ -769,6 +548,4 @@
 	
 	memset(br, 0, 512);
-	br->media_id = 0;
-	br->pad0 = 0;
 	br->signature = host2uint16_t_le(BR_SIGNATURE);
 	
@@ -847,12 +624,8 @@
 	p->ebr_addr = addr;
 	rc = mbr_add_partition(parts, p);
-	if (rc != ERR_OK) {
-		printf(LIBMBR_NAME ": Error occured during decoding the MBR. (%d)\n" \
-			   LIBMBR_NAME ": Partition list may be incomplete.\n", rc);
+	if (rc != ERR_OK) 
 		return EINVAL;
-	}
 	
 	addr = uint32_t_le2host(ebr->pte[1].first_lba) + base;
-	printf("DEBUG: b: %u, a: %u, start: %u\n", base, addr, ebr->pte[1].first_lba);
 	
 	while (ebr->pte[1].ptype != PT_UNUSED) {
@@ -879,5 +652,5 @@
 		}
 		
-		//printf("DEBUG: b: %u, a: %u, start: %u\n", base, addr, ebr->pte[0].first_lba);
+		
 		decode_part(&(ebr->pte[0]), p, addr);
 		mbr_set_flag(p, ST_LOGIC, true);
@@ -885,9 +658,6 @@
 		p->ebr_addr = addr;
 		rc = mbr_add_partition(parts, p);
-		if (rc != ERR_OK) {
-			printf(LIBMBR_NAME ": Error occured during decoding the MBR. (%d)\n" \
-				   LIBMBR_NAME ": Partition list may be incomplete.\n", rc);
+		if (rc != ERR_OK)
 			return EINVAL;
-		}
 		
 		addr = uint32_t_le2host(ebr->pte[1].first_lba) + base;
@@ -934,4 +704,8 @@
 }
 
+/** Check whether two partitions overlap
+ * 
+ * @return		1 for yes, 0 for no
+ */
 static int check_overlap(mbr_part_t * p1, mbr_part_t * p2)
 {
@@ -945,4 +719,8 @@
 }
 
+/** Check whether one partition encapsulates the other
+ * 
+ * @return		1 for yes, 0 for no
+ */
 static int check_encaps(mbr_part_t * inner, mbr_part_t * outer)
 {
@@ -956,4 +734,8 @@
 }
 
+/** Check whether one partition preceeds the other
+ * 
+ * @return		1 for yes, 0 for no
+ */
 static int check_preceeds(mbr_part_t * preceeder, mbr_part_t * precedee)
 {
@@ -961,27 +743,5 @@
 }
 
-static void debug_print(unsigned char * data, size_t bytes)
-{
-	size_t addr = 0;
-	int i;
-	
-	while (bytes >= 16) {
-		printf("%8x ", addr);
-		for (i = 0; i < 8; i++) {
-			printf(" %2hhx", data[addr + i]);
-		}
-		printf(" ");
-		for (i = 0; i < 8; i++) {
-			printf(" %2hhx", data[addr + i + 8]);
-		}
-		printf("\n");
-		
-		bytes -= 16;
-		addr += 16;
-	}
-	
-	
-}
-
-
-
+
+
+
