Se puede simplificar el code... pero ahí está mi intento... Deberías identar tu code...

::Cuenta atrás
::Batchiano
@echo off
setlocal enabledelayedexpansion
:menu
set /p h="Horas: "
set /p m="Minutos: "
set /p s="Segundos: "
for %%z in (h,m,s) do if not defined %%z (
	call :formato
)
if %h% GEQ 0 (
	if %m% GEQ 0 (
		if %m% LEQ 59 (
			if %s% GEQ 0 (
				if %s% LEQ 59 (
					call :contador
				) else (
					call :formato
				)
			) else (
				call :fomato
			)
		) else (
			call :formato
		)
	) else (
		call :formato
	)
) else (
	call :formato
)
goto :eof
 
:contador
cls
if %h% GEQ 0 (
	if %m% GEQ 0 (
		if %s% GEQ 0 (
			for /l %%a in (!h!,-1,0) do (
				for /l %%b in (!m!,-1,0) do (
					for /l %%c in (!s!,-1,0) do (
						echo Contador: %%a:%%b:%%c
						ping localhost -n 2 > nul
						cls
					)
					set s=59
				)
				set m=59
			)
		)
	)
)
goto :eof
 
:formato
echo Formato incorrecto. Vuelva a intentarlo
pause>nul & cls & call :menu
 

? Batch trabaja en Z y con límites dependiendo de la computadora.

No entiendo como antes de escribir en el foro no hacen pruebas. Tan simple como en cmd poner:

set /a 0-1

Ahí tienes la función dectobin:

@echo off
:: Batchiano para elhacker.net :)
set decimal=%1
set bin=2
set "resultado="
set "dectobin="
:dectobin
	set /a r=%decimal%%%bin%
	set /a decimal=%decimal% / %bin%
	set resultado=%r%%resultado%
	if %decimal% GTR 0 (goto dectobin)
	set dectobin=%resultado%

Como se puede apreciar, los restos se colocan inversamente.

Puedes hacer un for.

Utiliza aritmética modular.

Un ejemplo de Unit - TAD Números Racionales - con implementación dinámica de punteros.

////////////////////////////////////////////////////////////
/////////////Nombre de Unidad: TAD Racionales///////////////
///////////////////Autor: Batchiano/////////////////////////
//////////////////////////////////////////////////////////
unit Racional;
 
interface
 
type
	tPRacional = ^tRacional; // Tipo puntero a racional
	tRacional = record // Tipo racional con un registro
		numerador,denominador:integer;
	end;
 
function CrearRacional(a,b:integer):tPRacional; { Crea un número racional }
function MostrarRacional(r:tPRacional):string; { Muestra un número racional }
function Numerador(r:tPRacional):integer; { Obtiene el numerador de un número racional }
function Denominador(r:tPRacional):integer; { Obtiene el denominador de un número racional }
function SumarRacional(r,s:tPRacional):tPRacional; { Suma dos números racionales }
function RestarRacional(r,s:tPRacional):tPRacional; { Resta el segundo número racional al primero }
function MultiplicarRacional(r,s:tPRacional):tPRacional; { Multiplica dos números racionales }
function DividirRacional(r,s:tPRacional):tPRacional; { Divide el primer número racional pasado por el segundo }
function SimplificarRacional(var r:tPRacional):tPRacional; { Simplifica un número racional }
function mcd(a,b:integer):integer; { Obtiene el m.c.d de dos enteros (en términos positivos) }
 
 
implementation
 
function min(a,b:integer):integer;
begin
	min:=a;
	if b<a then
		min:=b;
end;
 
function CrearRacional(a,b:integer):tPRacional;
begin
	new(CrearRacional);
	CrearRacional^.numerador := a;
	CrearRacional^.denominador := b;
end;
 
function MostrarRacional(r:tPRacional):string;
var num,den:string;
begin
	if ((numerador(r)>0) and (denominador(r)>0)) or ((numerador(r)<0) and (denominador(r)<0)) then begin
		str(abs(numerador(r)),num);
		str(abs(denominador(r)),den);
		MostrarRacional := num + '/' + den;
	end
	else begin
		str(abs(numerador(r)),num);
		str(abs(denominador(r)),den);
		MostrarRacional := '-' + num + '/' + den;
	end;
 
end;
 
function Numerador(r:tPRacional):integer;
begin
	numerador := r^.numerador;
end;
 
function Denominador(r:tPRacional):integer;
begin
	denominador := r^.denominador;
end;
 
function SimplificarRacional(var r:tPRacional):tPRacional;
var a,b:integer;
begin
	a:=abs(numerador(r));
	b:=abs(denominador(r));
	r^.numerador := numerador(r) div mcd(a,b);
	r^.denominador := denominador(r) div mcd(a,b);
	SimplificarRacional := r;
end;
 
function SumarRacional(r,s:tPRacional):tPRacional;
begin
	new(SumarRacional);
	SumarRacional^.denominador := denominador(r) * denominador(s);
	SumarRacional^.numerador := denominador(SumarRacional) div denominador(r) * numerador(r) + denominador(SumarRacional) div denominador(s) * numerador(s);
	SumarRacional := SimplificarRacional(SumarRacional);
end;
 
function RestarRacional(r,s:tPRacional):tPRacional;
begin
	new(RestarRacional);
	RestarRacional^.denominador := denominador(r) * denominador(s);
	RestarRacional^.numerador := denominador(RestarRacional) div denominador(r) * numerador(r) - denominador(RestarRacional) div denominador(s) * numerador(s);
	RestarRacional := SimplificarRacional(RestarRacional);
end;
 
function MultiplicarRacional(r,s:tPRacional):tPRacional;
begin
	new(MultiplicarRacional);
	MultiplicarRacional^.numerador := numerador(r) * numerador(s);
	MultiplicarRacional^.denominador := denominador(r) * denominador(s);
	MultiplicarRacional := SimplificarRacional(MultiplicarRacional);
end;
 
function DividirRacional(r,s:tPRacional):tPRacional;
begin
	new(DividirRacional);
	DividirRacional^.numerador := numerador(r) * denominador(s);
	DividirRacional^.denominador := denominador(r) * numerador(s);
	DividirRacional := SimplificarRacional(DividirRacional);
end;
 
function mcd(a,b:integer):integer;
var t:integer;
begin
	a:=abs(a);
	b:=abs(b);
	t:=min(a,b);
	while (t>1) and (((b mod t) <> 0) or ((a mod t) <> 0)) do begin
		t:=t-1;
	end;
	mcd := t;
end;
 
begin
 
end.
 

También puedes diseñar un include de operaciones para manejar esta lista estática específica.

Sí, el código se puede optimizar xD pero no sé por qué tuve muchos problemas por los argumentos y bueno ahora es lo que es pero al menos funciona correctamente.

¡Saludos!

http://www.2shared.com/document/LREIj_kY/tema1.html

Apartado 1.8.2

¡Suerte!

http://www.2shared.com/document/LREIj_kY/tema1.html

Apartado 1.8.2

¡Suerte!