import java.util.regex.Matcher;
import java.util.regex.Pattern;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.buffer.Unpooled;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		
//		String balace = "/*!mycat:schema= helper */";
//		// String regx = "~/\\*\\!mycat:schema.*=([a-zA-Z0-9\\-]*)";
//		String regx = "/\\*\\!mycat:schema.*=([\\s\\w]*)\\*/$";
//		
//		Pattern pattern = Pattern.compile(regx);
//		Matcher m = pattern.matcher(balace);
//		
//		System.out.println(m.matches());
//		System.out.println(m.groupCount());
//		
//		System.out.println(m.group(1));
		
		
	//	System.out.println(Unpooled.directBuffer());
		
		
		PooledByteBufAllocator a = new PooledByteBufAllocator(false);
		ByteBuf buf = a.heapBuffer(252);
		System.out.println(buf);
		System.out.println(buf.arrayOffset());
		
		
		ByteBuf buf2 = a.heapBuffer(252);
		System.out.println(buf2);
		System.out.println(buf2.arrayOffset());
		
//		
//		ByteBuf buf2 = a.heapBuffer(35);
//		System.out.println(buf2);
//		
//		buf2.writeInt(10);
//		buf2.writeInt(12);
//		
//		ByteBuf buf3 = a.heapBuffer(35);
//		System.out.println(buf3);
		
//		System.out.println(allocateNode(2));
//		System.out.println(allocateNode(2));
//		System.out.println(allocateNode(2));
		
		System.out.println(normalizeCapacity(555));
		
		System.out.println(tabInx(1023));
		
		System.out.println(1024 >>> 10);
		
		

	}
	
	static int tabInx(int normCapacity) {
		 int i = normCapacity >>> 10;
		 int tableIdx = 0;
 while (i != 0) {
 i >>>= 1;
 tableIdx ++;
 }
 return tableIdx;
	}
 	
	static int normalizeCapacity(int reqCapacity) {
 if (reqCapacity < 0) {
 throw new IllegalArgumentException("capacity: " + reqCapacity + " (expected: 0+)");
 }
 if (reqCapacity >= 1<<30) {
 return reqCapacity;
 }

 if ((reqCapacity & 0xFFFFFE00) != 0) { // >= 512
 // Doubled

 int normalizedCapacity = reqCapacity;
 normalizedCapacity |= normalizedCapacity >>> 1;
 normalizedCapacity |= normalizedCapacity >>> 2;
 normalizedCapacity |= normalizedCapacity >>> 4;
 normalizedCapacity |= normalizedCapacity >>> 8;
 normalizedCapacity |= normalizedCapacity >>> 16;
 normalizedCapacity ++;

 if (normalizedCapacity < 0) {
 normalizedCapacity >>>= 1;
 }

 return normalizedCapacity;
 }

 // Quantum-spaced
 if ((reqCapacity & 15) == 0) {
 return reqCapacity;
 }

 return (reqCapacity & ~15) + 16;
 }
	
	static byte[] memoryMap = new byte[]{0,1,1,2,2,2,2};
	
	static byte value(int id) {
		return memoryMap[id];
	}
	
	static int allocateNode(int d) {
		int id = 1;
 int initial = - (1 << d); // has last d bits = 0 and rest all = 1
 byte val = value(id);
 if (val > d) { // unusable
 return -1;
 }
 while (val < d || (id & initial) == 0) { // id & initial == 1 << d for all ids at depth d, for < d it is 0
 id <<= 1;
 val = value(id);
 if (val > d) {
 id ^= 1;
 val = value(id);
 }
 }
 byte value = value(id);
 assert value == d && (id & initial) == 1 << d : String.format("val = %d, id & initial = %d, d = %d",
 value, id & initial, d);
 setValue(id, (byte)3); // mark as unusable
 updateParentsAlloc(id);
 return id;
 }
	
	static void setValue(int id, byte val) {
 memoryMap[id] = val;
 }
	
	 static void updateParentsAlloc(int id) {
	 while (id > 1) {
	 int parentId = id >>> 1;
	 byte val1 = value(id);
	 byte val2 = value(id ^ 1);
	 byte val = val1 < val2 ? val1 : val2;
	 setValue(parentId, val);
	 id = parentId;
	 }
	 }

}