Index: src/tools.h
==================================================================
--- src/tools.h
+++ src/tools.h
@@ -66,42 +66,46 @@
 inline void
 strn0cpy(char *d, const char *s, size_t m)
 {
 	strncpy(d, s, m);
 	d[(m)-1] = 0;
-};
+}
+
 inline void
 strcpy_s(char *d, const char *s)
 {
 	strn0cpy(d, s, _MAXDEFSTR);
-};
+}
+
 inline void
 strcat_s(char *d, const char *s)
 {
 	size_t n = strlen(d);
 	strn0cpy(d + n, s, _MAXDEFSTR - n);
-};
+}
 
 inline void
 formatstring(char *d, const char *fmt, va_list v)
 {
 	_vsnprintf(d, _MAXDEFSTR, fmt, v);
 	d[_MAXDEFSTR - 1] = 0;
-};
+}
 
 struct sprintf_s_f {
 	char *d;
+
 	sprintf_s_f(char *str) : d(str) {};
+
 	void
 	operator()(const char *fmt, ...)
 	{
 		va_list v;
 		va_start(v, fmt);
 		_vsnprintf(d, _MAXDEFSTR, fmt, v);
 		va_end(v);
 		d[_MAXDEFSTR - 1] = 0;
-	};
+	}
 };
 
 #define sprintf_s(d) sprintf_s_f((char *)d)
 #define sprintf_sd(d)                                                          \
 	string d;                                                              \
@@ -114,26 +118,11 @@
 		formatstring(d, fmt, ap);                                      \
 		va_end(ap);                                                    \
 	}
 #define sprintf_sdv(d, fmt) sprintf_sdlv(d, fmt, fmt)
 
-// fast pentium f2i
-
-#ifdef _MSC_VER
-inline int
-fast_f2nat(float a)
-{ // only for positive floats
-	static const float fhalf = 0.5f;
-	int retval;
-
-	__asm fld a __asm fsub fhalf __asm fistp retval // perf regalloc?
-
-	    return retval;
-};
-#else
-# define fast_f2nat(val) ((int)(val))
-#endif
+#define fast_f2nat(val) ((int)(val))
 
 extern char *path(char *s);
 extern char *loadfile(char *fn, int *size);
 extern void endianswap(void *, int, int);
 
@@ -145,15 +134,17 @@
 	enum { PTRSIZE = sizeof(char *) };
 	enum {
 		MAXBUCKETS = 65
 	}; // meaning up to size 256 on 32bit pointer systems
 	enum { MAXREUSESIZE = MAXBUCKETS * PTRSIZE - PTRSIZE };
+
 	inline size_t
 	bucket(size_t s)
 	{
 		return (s + PTRSIZE - 1) >> PTRBITS;
-	};
+	}
+
 	enum { PTRBITS = PTRSIZE == 2 ? 1 : PTRSIZE == 4 ? 2 : 3 };
 
 	char *p;
 	size_t left;
 	char *blocks;
@@ -202,17 +193,17 @@
 	{
 		this->p = gp();
 		alen = 8;
 		buf = (T *)p->alloc(alen * sizeof(T));
 		ulen = 0;
-	};
+	}
 
 	~vector()
 	{
 		setsize(0);
 		p->dealloc(buf, alen * sizeof(T));
-	};
+	}
 
 	vector(vector<T> &v);
 	void operator=(vector<T> &v);
 
 	T &
@@ -220,94 +211,99 @@
 	{
 		if (ulen == alen)
 			realloc();
 		new (&buf[ulen]) T(x);
 		return buf[ulen++];
-	};
+	}
 
 	T &
 	add()
 	{
 		if (ulen == alen)
 			realloc();
 		new (&buf[ulen]) T;
 		return buf[ulen++];
-	};
+	}
 
 	T &
 	pop()
 	{
 		return buf[--ulen];
-	};
+	}
+
 	T &
 	last()
 	{
 		return buf[ulen - 1];
-	};
+	}
+
 	bool
 	empty()
 	{
 		return ulen == 0;
-	};
+	}
 
 	int
 	length()
 	{
 		return ulen;
-	};
+	}
+
 	T &
 	operator[](int i)
 	{
 		assert(i >= 0 && i < ulen);
 		return buf[i];
-	};
+	}
+
 	void
 	setsize(int i)
 	{
 		for (; ulen > i; ulen--)
 			buf[ulen - 1].~T();
-	};
+	}
+
 	T *
 	getbuf()
 	{
 		return buf;
-	};
+	}
 
 	void
 	sort(void *cf)
 	{
 		qsort(buf, ulen, sizeof(T),
 		    (int(__cdecl *)(const void *, const void *))cf);
-	};
+	}
 
 	void
 	realloc()
 	{
 		int olen = alen;
 		buf = (T *)p->realloc(
 		    buf, olen * sizeof(T), (alen *= 2) * sizeof(T));
-	};
+	}
 
 	T
 	remove(int i)
 	{
 		T e = buf[i];
 		for (int p = i + 1; p < ulen; p++)
 			buf[p - 1] = buf[p];
 		ulen--;
 		return e;
-	};
+	}
 
 	T &
 	insert(int i, const T &e)
 	{
 		add(T());
 		for (int p = ulen - 1; p > i; p--)
 			buf[p] = buf[p - 1];
 		buf[i] = e;
 		return buf[i];
-	};
+	}
 };
 
 #define loopv(v)                                                               \
 	if (false) {                                                           \
 	} else                                                                 \