# /usr/src/release/picobsd/build/build_dir-net/crunch.mk - generated from /usr/src/release/picobsd/build/build_dir-net/crunch1.conf by crunchgen 0.2

LIBS= -lncurses -lmytinfo -lipx -lz -lpcap -lalias -lwrap -ledit -lutil -lcrypt -lmp -lgmp -lm -lkvm -lgnuregex -ltelnet -lskey -lmd
MAKEOBJDIRPREFIX?=/usr/obj-pico/picobsd/
MAKE=env MAKEOBJDIRPREFIX=$(MAKEOBJDIRPREFIX) make
BUILDOPTS+= -DNOPAM -DRELEASE_CRUNCH -DNOSECURE -DNOCRYPT -DNONETGRAPH -DNOIPSEC
CRUNCHED_OBJS= sh.lo test.lo echo.lo hostname.lo ln.lo login.lo getty.lo stty.lo inetd.lo telnetd.lo w.lo msg.lo kget.lo reboot.lo init.lo ifconfig.lo df.lo sps.lo ns.lo vm.lo cat.lo dd.lo cp.lo rm.lo mknod.lo chmod.lo chown.lo mkdir.lo ls.lo syslogd.lo sysctl.lo route.lo pwd_mkdb.lo dev_mkdb.lo mount.lo mount_msdos.lo umount.lo kill.lo mount_std.lo ftp.lo mv.lo ee.lo ftpd.lo pppd.lo ldconfig.lo pwd.lo telnet.lo less.lo passwd.lo date.lo mount_cd9660.lo mount_nfs.lo ping.lo traceroute.lo tar.lo grep.lo minigzip.lo
SUBMAKE_TARGETS= sh_make test_make echo_make hostname_make ln_make login_make getty_make stty_make inetd_make telnetd_make w_make msg_make kget_make reboot_make init_make ifconfig_make df_make sps_make ns_make vm_make cat_make dd_make cp_make rm_make mknod_make chmod_make chown_make mkdir_make ls_make syslogd_make sysctl_make route_make pwd_mkdb_make dev_mkdb_make mount_make mount_msdos_make umount_make kill_make mount_std_make ftp_make mv_make ee_make ftpd_make pppd_make ldconfig_make pwd_make telnet_make less_make passwd_make date_make mount_cd9660_make mount_nfs_make ping_make traceroute_make tar_make grep_make minigzip_make
SUBCLEAN_TARGETS= sh_clean test_clean echo_clean hostname_clean ln_clean login_clean getty_clean stty_clean inetd_clean telnetd_clean w_clean msg_clean kget_clean reboot_clean init_clean ifconfig_clean df_clean sps_clean ns_clean vm_clean cat_clean dd_clean cp_clean rm_clean mknod_clean chmod_clean chown_clean mkdir_clean ls_clean syslogd_clean sysctl_clean route_clean pwd_mkdb_clean dev_mkdb_clean mount_clean mount_msdos_clean umount_clean kill_clean mount_std_clean ftp_clean mv_clean ee_clean ftpd_clean pppd_clean ldconfig_clean pwd_clean telnet_clean less_clean passwd_clean date_clean mount_cd9660_clean mount_nfs_clean ping_clean traceroute_clean tar_clean grep_clean minigzip_clean

all: objs exe
objs: $(SUBMAKE_TARGETS)
exe: crunch1
crunch1: crunch1.o $(CRUNCHED_OBJS)
	$(CC) -static -o crunch1 crunch1.o $(CRUNCHED_OBJS) $(LIBS)
	strip crunch1
realclean: clean subclean
clean:
	rm -f crunch1 *.lo *.o *_stub.c
subclean: $(SUBCLEAN_TARGETS)

# -------- sh

sh_SRCDIR=/usr/src/bin/sh
sh_REALSRCDIR=/usr/src/bin/sh
sh_OBJDIR=$(MAKEOBJDIRPREFIX)/$(sh_REALSRCDIR)

sh_OBJS= alias.o arith.o arith_lex.o cd.o echo.o error.o eval.o exec.o expand.o histedit.o input.o jobs.o mail.o main.o memalloc.o miscbltin.o mystring.o options.o output.o parser.o printf.o redir.o show.o trap.o var.o builtins.o init.o nodes.o syntax.o
sh_make:
	(cd $(sh_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(sh_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(sh_OPTS) $(sh_OBJS))
sh_clean:
	(cd $(sh_SRCDIR) && $(MAKE) clean)

sh_OBJPATHS= $(sh_OBJDIR)/alias.o $(sh_OBJDIR)/arith.o $(sh_OBJDIR)/arith_lex.o $(sh_OBJDIR)/cd.o $(sh_OBJDIR)/echo.o $(sh_OBJDIR)/error.o $(sh_OBJDIR)/eval.o $(sh_OBJDIR)/exec.o $(sh_OBJDIR)/expand.o $(sh_OBJDIR)/histedit.o $(sh_OBJDIR)/input.o $(sh_OBJDIR)/jobs.o $(sh_OBJDIR)/mail.o $(sh_OBJDIR)/main.o $(sh_OBJDIR)/memalloc.o $(sh_OBJDIR)/miscbltin.o $(sh_OBJDIR)/mystring.o $(sh_OBJDIR)/options.o $(sh_OBJDIR)/output.o $(sh_OBJDIR)/parser.o $(sh_OBJDIR)/printf.o $(sh_OBJDIR)/redir.o $(sh_OBJDIR)/show.o $(sh_OBJDIR)/trap.o $(sh_OBJDIR)/var.o $(sh_OBJDIR)/builtins.o $(sh_OBJDIR)/init.o $(sh_OBJDIR)/nodes.o $(sh_OBJDIR)/syntax.o
sh_stub.c:
	echo "int _crunched_sh_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >sh_stub.c
sh.lo: sh_stub.o $(sh_OBJPATHS)
	ld -dc -r -o sh.lo sh_stub.o $(sh_OBJPATHS)
	crunchide -k _crunched_sh_stub sh.lo

# -------- test

test_SRCDIR=/usr/src/bin/test
test_REALSRCDIR=/usr/src/bin/test
test_OBJDIR=$(MAKEOBJDIRPREFIX)/$(test_REALSRCDIR)

test_OBJS= test.o
test_make:
	(cd $(test_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(test_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(test_OPTS) $(test_OBJS))
test_clean:
	(cd $(test_SRCDIR) && $(MAKE) clean)

test_OBJPATHS= $(test_OBJDIR)/test.o
test_stub.c:
	echo "int _crunched_test_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >test_stub.c
test.lo: test_stub.o $(test_OBJPATHS)
	ld -dc -r -o test.lo test_stub.o $(test_OBJPATHS)
	crunchide -k _crunched_test_stub test.lo

# -------- echo

echo_SRCDIR=/usr/src/bin/echo
echo_REALSRCDIR=/usr/src/bin/echo
echo_OBJDIR=$(MAKEOBJDIRPREFIX)/$(echo_REALSRCDIR)

echo_OBJS= echo.o
echo_make:
	(cd $(echo_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(echo_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(echo_OPTS) $(echo_OBJS))
echo_clean:
	(cd $(echo_SRCDIR) && $(MAKE) clean)

echo_OBJPATHS= $(echo_OBJDIR)/echo.o
echo_stub.c:
	echo "int _crunched_echo_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >echo_stub.c
echo.lo: echo_stub.o $(echo_OBJPATHS)
	ld -dc -r -o echo.lo echo_stub.o $(echo_OBJPATHS)
	crunchide -k _crunched_echo_stub echo.lo

# -------- hostname

hostname_SRCDIR=/usr/src/bin/hostname
hostname_REALSRCDIR=/usr/src/bin/hostname
hostname_OBJDIR=$(MAKEOBJDIRPREFIX)/$(hostname_REALSRCDIR)

hostname_OBJS= hostname.o
hostname_make:
	(cd $(hostname_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(hostname_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(hostname_OPTS) $(hostname_OBJS))
hostname_clean:
	(cd $(hostname_SRCDIR) && $(MAKE) clean)

hostname_OBJPATHS= $(hostname_OBJDIR)/hostname.o
hostname_stub.c:
	echo "int _crunched_hostname_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >hostname_stub.c
hostname.lo: hostname_stub.o $(hostname_OBJPATHS)
	ld -dc -r -o hostname.lo hostname_stub.o $(hostname_OBJPATHS)
	crunchide -k _crunched_hostname_stub hostname.lo

# -------- ln

ln_SRCDIR=/usr/src/bin/ln
ln_REALSRCDIR=/usr/src/bin/ln
ln_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ln_REALSRCDIR)

ln_OBJS= ln.o
ln_make:
	(cd $(ln_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ln_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ln_OPTS) $(ln_OBJS))
ln_clean:
	(cd $(ln_SRCDIR) && $(MAKE) clean)

ln_OBJPATHS= $(ln_OBJDIR)/ln.o
ln_stub.c:
	echo "int _crunched_ln_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ln_stub.c
ln.lo: ln_stub.o $(ln_OBJPATHS)
	ld -dc -r -o ln.lo ln_stub.o $(ln_OBJPATHS)
	crunchide -k _crunched_ln_stub ln.lo

# -------- login

login_SRCDIR=/usr/src/usr.bin/login
login_REALSRCDIR=/usr/src/usr.bin/login
login_OBJDIR=$(MAKEOBJDIRPREFIX)/$(login_REALSRCDIR)

login_OBJS= login.o login_access.o login_fbtab.o
login_make:
	(cd $(login_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(login_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(login_OPTS) $(login_OBJS))
login_clean:
	(cd $(login_SRCDIR) && $(MAKE) clean)

login_OBJPATHS= $(login_OBJDIR)/login.o $(login_OBJDIR)/login_access.o $(login_OBJDIR)/login_fbtab.o
login_stub.c:
	echo "int _crunched_login_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >login_stub.c
login.lo: login_stub.o $(login_OBJPATHS)
	ld -dc -r -o login.lo login_stub.o $(login_OBJPATHS)
	crunchide -k _crunched_login_stub login.lo

# -------- getty

getty_SRCDIR=/usr/src/libexec/getty
getty_REALSRCDIR=/usr/src/libexec/getty
getty_OBJDIR=$(MAKEOBJDIRPREFIX)/$(getty_REALSRCDIR)

getty_OBJS= main.o init.o subr.o chat.o
getty_make:
	(cd $(getty_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(getty_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(getty_OPTS) $(getty_OBJS))
getty_clean:
	(cd $(getty_SRCDIR) && $(MAKE) clean)

getty_OBJPATHS= $(getty_OBJDIR)/main.o $(getty_OBJDIR)/init.o $(getty_OBJDIR)/subr.o $(getty_OBJDIR)/chat.o
getty_stub.c:
	echo "int _crunched_getty_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >getty_stub.c
getty.lo: getty_stub.o $(getty_OBJPATHS)
	ld -dc -r -o getty.lo getty_stub.o $(getty_OBJPATHS)
	crunchide -k _crunched_getty_stub getty.lo

# -------- stty

stty_SRCDIR=/usr/src/bin/stty
stty_REALSRCDIR=/usr/src/bin/stty
stty_OBJDIR=$(MAKEOBJDIRPREFIX)/$(stty_REALSRCDIR)

stty_OBJS= cchar.o gfmt.o key.o modes.o print.o stty.o util.o
stty_make:
	(cd $(stty_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(stty_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(stty_OPTS) $(stty_OBJS))
stty_clean:
	(cd $(stty_SRCDIR) && $(MAKE) clean)

stty_OBJPATHS= $(stty_OBJDIR)/cchar.o $(stty_OBJDIR)/gfmt.o $(stty_OBJDIR)/key.o $(stty_OBJDIR)/modes.o $(stty_OBJDIR)/print.o $(stty_OBJDIR)/stty.o $(stty_OBJDIR)/util.o
stty_stub.c:
	echo "int _crunched_stty_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >stty_stub.c
stty.lo: stty_stub.o $(stty_OBJPATHS)
	ld -dc -r -o stty.lo stty_stub.o $(stty_OBJPATHS)
	crunchide -k _crunched_stty_stub stty.lo

# -------- inetd

inetd_SRCDIR=/usr/src/usr.sbin/inetd
inetd_REALSRCDIR=/usr/src/usr.sbin/inetd
inetd_OBJDIR=$(MAKEOBJDIRPREFIX)/$(inetd_REALSRCDIR)

inetd_OBJS= inetd.o builtins.o
inetd_make:
	(cd $(inetd_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(inetd_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(inetd_OPTS) $(inetd_OBJS))
inetd_clean:
	(cd $(inetd_SRCDIR) && $(MAKE) clean)

inetd_OBJPATHS= $(inetd_OBJDIR)/inetd.o $(inetd_OBJDIR)/builtins.o
inetd_stub.c:
	echo "int _crunched_inetd_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >inetd_stub.c
inetd.lo: inetd_stub.o $(inetd_OBJPATHS)
	ld -dc -r -o inetd.lo inetd_stub.o $(inetd_OBJPATHS)
	crunchide -k _crunched_inetd_stub inetd.lo

# -------- telnetd

telnetd_SRCDIR=/usr/src/libexec/telnetd
telnetd_REALSRCDIR=/usr/src/libexec/telnetd
telnetd_OBJDIR=$(MAKEOBJDIRPREFIX)/$(telnetd_REALSRCDIR)

telnetd_OBJS= global.o slc.o state.o sys_term.o telnetd.o termstat.o utility.o
telnetd_make:
	(cd $(telnetd_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(telnetd_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(telnetd_OPTS) $(telnetd_OBJS))
telnetd_clean:
	(cd $(telnetd_SRCDIR) && $(MAKE) clean)

telnetd_OBJPATHS= $(telnetd_OBJDIR)/global.o $(telnetd_OBJDIR)/slc.o $(telnetd_OBJDIR)/state.o $(telnetd_OBJDIR)/sys_term.o $(telnetd_OBJDIR)/telnetd.o $(telnetd_OBJDIR)/termstat.o $(telnetd_OBJDIR)/utility.o
telnetd_stub.c:
	echo "int _crunched_telnetd_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >telnetd_stub.c
telnetd.lo: telnetd_stub.o $(telnetd_OBJPATHS)
	ld -dc -r -o telnetd.lo telnetd_stub.o $(telnetd_OBJPATHS)
	crunchide -k _crunched_telnetd_stub telnetd.lo

# -------- w

w_SRCDIR=/usr/src/usr.bin/w
w_REALSRCDIR=/usr/src/usr.bin/w
w_OBJDIR=$(MAKEOBJDIRPREFIX)/$(w_REALSRCDIR)

w_OBJS= fmt.o pr_time.o proc_compare.o w.o
w_make:
	(cd $(w_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(w_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(w_OPTS) $(w_OBJS))
w_clean:
	(cd $(w_SRCDIR) && $(MAKE) clean)

w_OBJPATHS= $(w_OBJDIR)/fmt.o $(w_OBJDIR)/pr_time.o $(w_OBJDIR)/proc_compare.o $(w_OBJDIR)/w.o
w_stub.c:
	echo "int _crunched_w_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >w_stub.c
w.lo: w_stub.o $(w_OBJPATHS)
	ld -dc -r -o w.lo w_stub.o $(w_OBJPATHS)
	crunchide -k _crunched_w_stub w.lo

# -------- msg

msg_SRCDIR=../../../tinyware/msg
msg_REALSRCDIR=/usr/src/release/picobsd/tinyware/msg
msg_OBJDIR=$(MAKEOBJDIRPREFIX)/$(msg_REALSRCDIR)

msg_OBJS= msg.o
msg_make:
	(cd $(msg_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(msg_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(msg_OPTS) $(msg_OBJS))
msg_clean:
	(cd $(msg_SRCDIR) && $(MAKE) clean)

msg_OBJPATHS= $(msg_OBJDIR)/msg.o
msg_stub.c:
	echo "int _crunched_msg_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >msg_stub.c
msg.lo: msg_stub.o $(msg_OBJPATHS)
	ld -dc -r -o msg.lo msg_stub.o $(msg_OBJPATHS)
	crunchide -k _crunched_msg_stub msg.lo

# -------- kget

kget_SRCDIR=/usr/src/sbin/kget
kget_REALSRCDIR=/usr/src/sbin/kget
kget_OBJDIR=$(MAKEOBJDIRPREFIX)/$(kget_REALSRCDIR)

kget_OBJS= kget.o
kget_make:
	(cd $(kget_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(kget_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(kget_OPTS) $(kget_OBJS))
kget_clean:
	(cd $(kget_SRCDIR) && $(MAKE) clean)

kget_OBJPATHS= $(kget_OBJDIR)/kget.o
kget_stub.c:
	echo "int _crunched_kget_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >kget_stub.c
kget.lo: kget_stub.o $(kget_OBJPATHS)
	ld -dc -r -o kget.lo kget_stub.o $(kget_OBJPATHS)
	crunchide -k _crunched_kget_stub kget.lo

# -------- reboot

reboot_SRCDIR=/usr/src/sbin/reboot
reboot_REALSRCDIR=/usr/src/sbin/reboot
reboot_OBJDIR=$(MAKEOBJDIRPREFIX)/$(reboot_REALSRCDIR)

reboot_OBJS= reboot.o
reboot_make:
	(cd $(reboot_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(reboot_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(reboot_OPTS) $(reboot_OBJS))
reboot_clean:
	(cd $(reboot_SRCDIR) && $(MAKE) clean)

reboot_OBJPATHS= $(reboot_OBJDIR)/reboot.o
reboot_stub.c:
	echo "int _crunched_reboot_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >reboot_stub.c
reboot.lo: reboot_stub.o $(reboot_OBJPATHS)
	ld -dc -r -o reboot.lo reboot_stub.o $(reboot_OBJPATHS)
	crunchide -k _crunched_reboot_stub reboot.lo

# -------- init

init_SRCDIR=/usr/src/sbin/init
init_REALSRCDIR=/usr/src/sbin/init
init_OBJDIR=$(MAKEOBJDIRPREFIX)/$(init_REALSRCDIR)

init_OBJS= init.o
init_make:
	(cd $(init_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(init_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(init_OPTS) $(init_OBJS))
init_clean:
	(cd $(init_SRCDIR) && $(MAKE) clean)

init_OBJPATHS= $(init_OBJDIR)/init.o
init_stub.c:
	echo "int _crunched_init_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >init_stub.c
init.lo: init_stub.o $(init_OBJPATHS)
	ld -dc -r -o init.lo init_stub.o $(init_OBJPATHS)
	crunchide -k _crunched_init_stub init.lo

# -------- ifconfig

ifconfig_SRCDIR=/usr/src/sbin/ifconfig
ifconfig_REALSRCDIR=/usr/src/sbin/ifconfig
ifconfig_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ifconfig_REALSRCDIR)

ifconfig_OBJS= ifconfig.o ifmedia.o
ifconfig_make:
	(cd $(ifconfig_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ifconfig_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ifconfig_OPTS) $(ifconfig_OBJS))
ifconfig_clean:
	(cd $(ifconfig_SRCDIR) && $(MAKE) clean)

ifconfig_OBJPATHS= $(ifconfig_OBJDIR)/ifconfig.o $(ifconfig_OBJDIR)/ifmedia.o
ifconfig_stub.c:
	echo "int _crunched_ifconfig_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ifconfig_stub.c
ifconfig.lo: ifconfig_stub.o $(ifconfig_OBJPATHS)
	ld -dc -r -o ifconfig.lo ifconfig_stub.o $(ifconfig_OBJPATHS)
	crunchide -k _crunched_ifconfig_stub ifconfig.lo

# -------- df

df_SRCDIR=/usr/src/bin/df
df_REALSRCDIR=/usr/src/bin/df
df_OBJDIR=$(MAKEOBJDIRPREFIX)/$(df_REALSRCDIR)

df_OBJS= df.o vfslist.o
df_make:
	(cd $(df_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(df_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(df_OPTS) $(df_OBJS))
df_clean:
	(cd $(df_SRCDIR) && $(MAKE) clean)

df_OBJPATHS= $(df_OBJDIR)/df.o $(df_OBJDIR)/vfslist.o
df_stub.c:
	echo "int _crunched_df_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >df_stub.c
df.lo: df_stub.o $(df_OBJPATHS)
	ld -dc -r -o df.lo df_stub.o $(df_OBJPATHS)
	crunchide -k _crunched_df_stub df.lo

# -------- sps

sps_SRCDIR=../../../tinyware/sps
sps_REALSRCDIR=/usr/src/release/picobsd/tinyware/sps
sps_OBJDIR=$(MAKEOBJDIRPREFIX)/$(sps_REALSRCDIR)

sps_OBJS= sps.o
sps_make:
	(cd $(sps_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(sps_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(sps_OPTS) $(sps_OBJS))
sps_clean:
	(cd $(sps_SRCDIR) && $(MAKE) clean)

sps_OBJPATHS= $(sps_OBJDIR)/sps.o
sps_stub.c:
	echo "int _crunched_sps_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >sps_stub.c
sps.lo: sps_stub.o $(sps_OBJPATHS)
	ld -dc -r -o sps.lo sps_stub.o $(sps_OBJPATHS)
	crunchide -k _crunched_sps_stub sps.lo

# -------- ns

ns_SRCDIR=../../../tinyware/ns
ns_REALSRCDIR=/usr/src/release/picobsd/tinyware/ns
ns_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ns_REALSRCDIR)

ns_OBJS= ns.o
ns_make:
	(cd $(ns_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ns_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ns_OPTS) $(ns_OBJS))
ns_clean:
	(cd $(ns_SRCDIR) && $(MAKE) clean)

ns_OBJPATHS= $(ns_OBJDIR)/ns.o
ns_stub.c:
	echo "int _crunched_ns_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ns_stub.c
ns.lo: ns_stub.o $(ns_OBJPATHS)
	ld -dc -r -o ns.lo ns_stub.o $(ns_OBJPATHS)
	crunchide -k _crunched_ns_stub ns.lo

# -------- vm

vm_SRCDIR=../../../tinyware/vm
vm_REALSRCDIR=/usr/src/release/picobsd/tinyware/vm
vm_OBJDIR=$(MAKEOBJDIRPREFIX)/$(vm_REALSRCDIR)

vm_OBJS= vm.o
vm_make:
	(cd $(vm_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(vm_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(vm_OPTS) $(vm_OBJS))
vm_clean:
	(cd $(vm_SRCDIR) && $(MAKE) clean)

vm_OBJPATHS= $(vm_OBJDIR)/vm.o
vm_stub.c:
	echo "int _crunched_vm_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >vm_stub.c
vm.lo: vm_stub.o $(vm_OBJPATHS)
	ld -dc -r -o vm.lo vm_stub.o $(vm_OBJPATHS)
	crunchide -k _crunched_vm_stub vm.lo

# -------- cat

cat_SRCDIR=/usr/src/bin/cat
cat_REALSRCDIR=/usr/src/bin/cat
cat_OBJDIR=$(MAKEOBJDIRPREFIX)/$(cat_REALSRCDIR)

cat_OBJS= cat.o
cat_make:
	(cd $(cat_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(cat_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(cat_OPTS) $(cat_OBJS))
cat_clean:
	(cd $(cat_SRCDIR) && $(MAKE) clean)

cat_OBJPATHS= $(cat_OBJDIR)/cat.o
cat_stub.c:
	echo "int _crunched_cat_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >cat_stub.c
cat.lo: cat_stub.o $(cat_OBJPATHS)
	ld -dc -r -o cat.lo cat_stub.o $(cat_OBJPATHS)
	crunchide -k _crunched_cat_stub cat.lo

# -------- dd

dd_SRCDIR=/usr/src/bin/dd
dd_REALSRCDIR=/usr/src/bin/dd
dd_OBJDIR=$(MAKEOBJDIRPREFIX)/$(dd_REALSRCDIR)

dd_OBJS= args.o conv.o conv_tab.o dd.o misc.o position.o
dd_make:
	(cd $(dd_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(dd_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(dd_OPTS) $(dd_OBJS))
dd_clean:
	(cd $(dd_SRCDIR) && $(MAKE) clean)

dd_OBJPATHS= $(dd_OBJDIR)/args.o $(dd_OBJDIR)/conv.o $(dd_OBJDIR)/conv_tab.o $(dd_OBJDIR)/dd.o $(dd_OBJDIR)/misc.o $(dd_OBJDIR)/position.o
dd_stub.c:
	echo "int _crunched_dd_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >dd_stub.c
dd.lo: dd_stub.o $(dd_OBJPATHS)
	ld -dc -r -o dd.lo dd_stub.o $(dd_OBJPATHS)
	crunchide -k _crunched_dd_stub dd.lo

# -------- cp

cp_SRCDIR=/usr/src/bin/cp
cp_REALSRCDIR=/usr/src/bin/cp
cp_OBJDIR=$(MAKEOBJDIRPREFIX)/$(cp_REALSRCDIR)

cp_OBJS= cp.o utils.o
cp_make:
	(cd $(cp_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(cp_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(cp_OPTS) $(cp_OBJS))
cp_clean:
	(cd $(cp_SRCDIR) && $(MAKE) clean)

cp_OBJPATHS= $(cp_OBJDIR)/cp.o $(cp_OBJDIR)/utils.o
cp_stub.c:
	echo "int _crunched_cp_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >cp_stub.c
cp.lo: cp_stub.o $(cp_OBJPATHS)
	ld -dc -r -o cp.lo cp_stub.o $(cp_OBJPATHS)
	crunchide -k _crunched_cp_stub cp.lo

# -------- rm

rm_SRCDIR=/usr/src/bin/rm
rm_REALSRCDIR=/usr/src/bin/rm
rm_OBJDIR=$(MAKEOBJDIRPREFIX)/$(rm_REALSRCDIR)

rm_OBJS= rm.o
rm_make:
	(cd $(rm_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(rm_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(rm_OPTS) $(rm_OBJS))
rm_clean:
	(cd $(rm_SRCDIR) && $(MAKE) clean)

rm_OBJPATHS= $(rm_OBJDIR)/rm.o
rm_stub.c:
	echo "int _crunched_rm_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >rm_stub.c
rm.lo: rm_stub.o $(rm_OBJPATHS)
	ld -dc -r -o rm.lo rm_stub.o $(rm_OBJPATHS)
	crunchide -k _crunched_rm_stub rm.lo

# -------- mknod

mknod_SRCDIR=/usr/src/sbin/mknod
mknod_REALSRCDIR=/usr/src/sbin/mknod
mknod_OBJDIR=$(MAKEOBJDIRPREFIX)/$(mknod_REALSRCDIR)

mknod_OBJS= mknod.o
mknod_make:
	(cd $(mknod_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(mknod_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(mknod_OPTS) $(mknod_OBJS))
mknod_clean:
	(cd $(mknod_SRCDIR) && $(MAKE) clean)

mknod_OBJPATHS= $(mknod_OBJDIR)/mknod.o
mknod_stub.c:
	echo "int _crunched_mknod_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >mknod_stub.c
mknod.lo: mknod_stub.o $(mknod_OBJPATHS)
	ld -dc -r -o mknod.lo mknod_stub.o $(mknod_OBJPATHS)
	crunchide -k _crunched_mknod_stub mknod.lo

# -------- chmod

chmod_SRCDIR=/usr/src/bin/chmod
chmod_REALSRCDIR=/usr/src/bin/chmod
chmod_OBJDIR=$(MAKEOBJDIRPREFIX)/$(chmod_REALSRCDIR)

chmod_OBJS= chmod.o
chmod_make:
	(cd $(chmod_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(chmod_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(chmod_OPTS) $(chmod_OBJS))
chmod_clean:
	(cd $(chmod_SRCDIR) && $(MAKE) clean)

chmod_OBJPATHS= $(chmod_OBJDIR)/chmod.o
chmod_stub.c:
	echo "int _crunched_chmod_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >chmod_stub.c
chmod.lo: chmod_stub.o $(chmod_OBJPATHS)
	ld -dc -r -o chmod.lo chmod_stub.o $(chmod_OBJPATHS)
	crunchide -k _crunched_chmod_stub chmod.lo

# -------- chown

chown_SRCDIR=/usr/src/usr.sbin/chown
chown_REALSRCDIR=/usr/src/usr.sbin/chown
chown_OBJDIR=$(MAKEOBJDIRPREFIX)/$(chown_REALSRCDIR)

chown_OBJS= chown.o
chown_make:
	(cd $(chown_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(chown_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(chown_OPTS) $(chown_OBJS))
chown_clean:
	(cd $(chown_SRCDIR) && $(MAKE) clean)

chown_OBJPATHS= $(chown_OBJDIR)/chown.o
chown_stub.c:
	echo "int _crunched_chown_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >chown_stub.c
chown.lo: chown_stub.o $(chown_OBJPATHS)
	ld -dc -r -o chown.lo chown_stub.o $(chown_OBJPATHS)
	crunchide -k _crunched_chown_stub chown.lo

# -------- mkdir

mkdir_SRCDIR=/usr/src/bin/mkdir
mkdir_REALSRCDIR=/usr/src/bin/mkdir
mkdir_OBJDIR=$(MAKEOBJDIRPREFIX)/$(mkdir_REALSRCDIR)

mkdir_OBJS= mkdir.o
mkdir_make:
	(cd $(mkdir_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(mkdir_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(mkdir_OPTS) $(mkdir_OBJS))
mkdir_clean:
	(cd $(mkdir_SRCDIR) && $(MAKE) clean)

mkdir_OBJPATHS= $(mkdir_OBJDIR)/mkdir.o
mkdir_stub.c:
	echo "int _crunched_mkdir_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >mkdir_stub.c
mkdir.lo: mkdir_stub.o $(mkdir_OBJPATHS)
	ld -dc -r -o mkdir.lo mkdir_stub.o $(mkdir_OBJPATHS)
	crunchide -k _crunched_mkdir_stub mkdir.lo

# -------- ls

ls_SRCDIR=/usr/src/bin/ls
ls_REALSRCDIR=/usr/src/bin/ls
ls_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ls_REALSRCDIR)

ls_OBJS= cmp.o ls.o print.o util.o
ls_make:
	(cd $(ls_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ls_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ls_OPTS) $(ls_OBJS))
ls_clean:
	(cd $(ls_SRCDIR) && $(MAKE) clean)

ls_OBJPATHS= $(ls_OBJDIR)/cmp.o $(ls_OBJDIR)/ls.o $(ls_OBJDIR)/print.o $(ls_OBJDIR)/util.o
ls_stub.c:
	echo "int _crunched_ls_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ls_stub.c
ls.lo: ls_stub.o $(ls_OBJPATHS)
	ld -dc -r -o ls.lo ls_stub.o $(ls_OBJPATHS)
	crunchide -k _crunched_ls_stub ls.lo

# -------- syslogd

syslogd_SRCDIR=/usr/src/usr.sbin/syslogd
syslogd_REALSRCDIR=/usr/src/usr.sbin/syslogd
syslogd_OBJDIR=$(MAKEOBJDIRPREFIX)/$(syslogd_REALSRCDIR)

syslogd_OBJS= syslogd.o ttymsg.o
syslogd_make:
	(cd $(syslogd_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(syslogd_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(syslogd_OPTS) $(syslogd_OBJS))
syslogd_clean:
	(cd $(syslogd_SRCDIR) && $(MAKE) clean)

syslogd_OBJPATHS= $(syslogd_OBJDIR)/syslogd.o $(syslogd_OBJDIR)/ttymsg.o
syslogd_stub.c:
	echo "int _crunched_syslogd_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >syslogd_stub.c
syslogd.lo: syslogd_stub.o $(syslogd_OBJPATHS)
	ld -dc -r -o syslogd.lo syslogd_stub.o $(syslogd_OBJPATHS)
	crunchide -k _crunched_syslogd_stub syslogd.lo

# -------- sysctl

sysctl_SRCDIR=/usr/src/sbin/sysctl
sysctl_REALSRCDIR=/usr/src/sbin/sysctl
sysctl_OBJDIR=$(MAKEOBJDIRPREFIX)/$(sysctl_REALSRCDIR)

sysctl_OBJS= sysctl.o
sysctl_make:
	(cd $(sysctl_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(sysctl_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(sysctl_OPTS) $(sysctl_OBJS))
sysctl_clean:
	(cd $(sysctl_SRCDIR) && $(MAKE) clean)

sysctl_OBJPATHS= $(sysctl_OBJDIR)/sysctl.o
sysctl_stub.c:
	echo "int _crunched_sysctl_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >sysctl_stub.c
sysctl.lo: sysctl_stub.o $(sysctl_OBJPATHS)
	ld -dc -r -o sysctl.lo sysctl_stub.o $(sysctl_OBJPATHS)
	crunchide -k _crunched_sysctl_stub sysctl.lo

# -------- route

route_SRCDIR=/usr/src/sbin/route
route_REALSRCDIR=/usr/src/sbin/route
route_OBJDIR=$(MAKEOBJDIRPREFIX)/$(route_REALSRCDIR)

route_OBJS= route.o
route_make:
	(cd $(route_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(route_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(route_OPTS) $(route_OBJS))
route_clean:
	(cd $(route_SRCDIR) && $(MAKE) clean)

route_OBJPATHS= $(route_OBJDIR)/route.o
route_stub.c:
	echo "int _crunched_route_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >route_stub.c
route.lo: route_stub.o $(route_OBJPATHS)
	ld -dc -r -o route.lo route_stub.o $(route_OBJPATHS)
	crunchide -k _crunched_route_stub route.lo

# -------- pwd_mkdb

pwd_mkdb_SRCDIR=/usr/src/usr.sbin/pwd_mkdb
pwd_mkdb_REALSRCDIR=/usr/src/usr.sbin/pwd_mkdb
pwd_mkdb_OBJDIR=$(MAKEOBJDIRPREFIX)/$(pwd_mkdb_REALSRCDIR)

pwd_mkdb_OBJS= pw_scan.o pwd_mkdb.o
pwd_mkdb_make:
	(cd $(pwd_mkdb_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(pwd_mkdb_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(pwd_mkdb_OPTS) $(pwd_mkdb_OBJS))
pwd_mkdb_clean:
	(cd $(pwd_mkdb_SRCDIR) && $(MAKE) clean)

pwd_mkdb_OBJPATHS= $(pwd_mkdb_OBJDIR)/pw_scan.o $(pwd_mkdb_OBJDIR)/pwd_mkdb.o
pwd_mkdb_stub.c:
	echo "int _crunched_pwd_mkdb_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >pwd_mkdb_stub.c
pwd_mkdb.lo: pwd_mkdb_stub.o $(pwd_mkdb_OBJPATHS)
	ld -dc -r -o pwd_mkdb.lo pwd_mkdb_stub.o $(pwd_mkdb_OBJPATHS)
	crunchide -k _crunched_pwd_mkdb_stub pwd_mkdb.lo

# -------- dev_mkdb

dev_mkdb_SRCDIR=/usr/src/usr.sbin/dev_mkdb
dev_mkdb_REALSRCDIR=/usr/src/usr.sbin/dev_mkdb
dev_mkdb_OBJDIR=$(MAKEOBJDIRPREFIX)/$(dev_mkdb_REALSRCDIR)

dev_mkdb_OBJS= dev_mkdb.o
dev_mkdb_make:
	(cd $(dev_mkdb_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(dev_mkdb_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(dev_mkdb_OPTS) $(dev_mkdb_OBJS))
dev_mkdb_clean:
	(cd $(dev_mkdb_SRCDIR) && $(MAKE) clean)

dev_mkdb_OBJPATHS= $(dev_mkdb_OBJDIR)/dev_mkdb.o
dev_mkdb_stub.c:
	echo "int _crunched_dev_mkdb_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >dev_mkdb_stub.c
dev_mkdb.lo: dev_mkdb_stub.o $(dev_mkdb_OBJPATHS)
	ld -dc -r -o dev_mkdb.lo dev_mkdb_stub.o $(dev_mkdb_OBJPATHS)
	crunchide -k _crunched_dev_mkdb_stub dev_mkdb.lo

# -------- mount

mount_SRCDIR=/usr/src/sbin/mount
mount_REALSRCDIR=/usr/src/sbin/mount
mount_OBJDIR=$(MAKEOBJDIRPREFIX)/$(mount_REALSRCDIR)

mount_OBJS= mount.o mount_ufs.o getmntopts.o vfslist.o
mount_make:
	(cd $(mount_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(mount_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(mount_OPTS) $(mount_OBJS))
mount_clean:
	(cd $(mount_SRCDIR) && $(MAKE) clean)

mount_OBJPATHS= $(mount_OBJDIR)/mount.o $(mount_OBJDIR)/mount_ufs.o $(mount_OBJDIR)/getmntopts.o $(mount_OBJDIR)/vfslist.o
mount_stub.c:
	echo "int _crunched_mount_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >mount_stub.c
mount.lo: mount_stub.o $(mount_OBJPATHS)
	ld -dc -r -o mount.lo mount_stub.o $(mount_OBJPATHS)
	crunchide -k _crunched_mount_stub mount.lo

# -------- mount_msdos

mount_msdos_SRCDIR=/usr/src/sbin/mount_msdos
mount_msdos_REALSRCDIR=/usr/src/sbin/mount_msdos
mount_msdos_OBJDIR=$(MAKEOBJDIRPREFIX)/$(mount_msdos_REALSRCDIR)

mount_msdos_OBJS= mount_msdos.o getmntopts.o
mount_msdos_make:
	(cd $(mount_msdos_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(mount_msdos_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(mount_msdos_OPTS) $(mount_msdos_OBJS))
mount_msdos_clean:
	(cd $(mount_msdos_SRCDIR) && $(MAKE) clean)

mount_msdos_OBJPATHS= $(mount_msdos_OBJDIR)/mount_msdos.o $(mount_msdos_OBJDIR)/getmntopts.o
mount_msdos_stub.c:
	echo "int _crunched_mount_msdos_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >mount_msdos_stub.c
mount_msdos.lo: mount_msdos_stub.o $(mount_msdos_OBJPATHS)
	ld -dc -r -o mount_msdos.lo mount_msdos_stub.o $(mount_msdos_OBJPATHS)
	crunchide -k _crunched_mount_msdos_stub mount_msdos.lo

# -------- umount

umount_SRCDIR=/usr/src/sbin/umount
umount_REALSRCDIR=/usr/src/sbin/umount
umount_OBJDIR=$(MAKEOBJDIRPREFIX)/$(umount_REALSRCDIR)

umount_OBJS= umount.o vfslist.o mounttab.o
umount_make:
	(cd $(umount_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(umount_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(umount_OPTS) $(umount_OBJS))
umount_clean:
	(cd $(umount_SRCDIR) && $(MAKE) clean)

umount_OBJPATHS= $(umount_OBJDIR)/umount.o $(umount_OBJDIR)/vfslist.o $(umount_OBJDIR)/mounttab.o
umount_stub.c:
	echo "int _crunched_umount_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >umount_stub.c
umount.lo: umount_stub.o $(umount_OBJPATHS)
	ld -dc -r -o umount.lo umount_stub.o $(umount_OBJPATHS)
	crunchide -k _crunched_umount_stub umount.lo

# -------- kill

kill_SRCDIR=/usr/src/bin/kill
kill_REALSRCDIR=/usr/src/bin/kill
kill_OBJDIR=$(MAKEOBJDIRPREFIX)/$(kill_REALSRCDIR)

kill_OBJS= kill.o
kill_make:
	(cd $(kill_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(kill_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(kill_OPTS) $(kill_OBJS))
kill_clean:
	(cd $(kill_SRCDIR) && $(MAKE) clean)

kill_OBJPATHS= $(kill_OBJDIR)/kill.o
kill_stub.c:
	echo "int _crunched_kill_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >kill_stub.c
kill.lo: kill_stub.o $(kill_OBJPATHS)
	ld -dc -r -o kill.lo kill_stub.o $(kill_OBJPATHS)
	crunchide -k _crunched_kill_stub kill.lo

# -------- mount_std

mount_std_SRCDIR=/usr/src/sbin/mount_std
mount_std_REALSRCDIR=/usr/src/sbin/mount_std
mount_std_OBJDIR=$(MAKEOBJDIRPREFIX)/$(mount_std_REALSRCDIR)

mount_std_OBJS= mount_std.o getmntopts.o
mount_std_make:
	(cd $(mount_std_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(mount_std_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(mount_std_OPTS) $(mount_std_OBJS))
mount_std_clean:
	(cd $(mount_std_SRCDIR) && $(MAKE) clean)

mount_std_OBJPATHS= $(mount_std_OBJDIR)/mount_std.o $(mount_std_OBJDIR)/getmntopts.o
mount_std_stub.c:
	echo "int _crunched_mount_std_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >mount_std_stub.c
mount_std.lo: mount_std_stub.o $(mount_std_OBJPATHS)
	ld -dc -r -o mount_std.lo mount_std_stub.o $(mount_std_OBJPATHS)
	crunchide -k _crunched_mount_std_stub mount_std.lo

# -------- ftp

ftp_SRCDIR=/usr/src/usr.bin/ftp
ftp_REALSRCDIR=/usr/src/usr.bin/ftp
ftp_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ftp_REALSRCDIR)

ftp_OBJS= cmds.o cmdtab.o complete.o domacro.o fetch.o ftp.o main.o ruserpass.o util.o
ftp_make:
	(cd $(ftp_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ftp_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ftp_OPTS) $(ftp_OBJS))
ftp_clean:
	(cd $(ftp_SRCDIR) && $(MAKE) clean)

ftp_OBJPATHS= $(ftp_OBJDIR)/cmds.o $(ftp_OBJDIR)/cmdtab.o $(ftp_OBJDIR)/complete.o $(ftp_OBJDIR)/domacro.o $(ftp_OBJDIR)/fetch.o $(ftp_OBJDIR)/ftp.o $(ftp_OBJDIR)/main.o $(ftp_OBJDIR)/ruserpass.o $(ftp_OBJDIR)/util.o
ftp_stub.c:
	echo "int _crunched_ftp_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ftp_stub.c
ftp.lo: ftp_stub.o $(ftp_OBJPATHS)
	ld -dc -r -o ftp.lo ftp_stub.o $(ftp_OBJPATHS)
	crunchide -k _crunched_ftp_stub ftp.lo

# -------- mv

mv_SRCDIR=/usr/src/bin/mv
mv_REALSRCDIR=/usr/src/bin/mv
mv_OBJDIR=$(MAKEOBJDIRPREFIX)/$(mv_REALSRCDIR)

mv_OBJS= mv.o
mv_make:
	(cd $(mv_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(mv_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(mv_OPTS) $(mv_OBJS))
mv_clean:
	(cd $(mv_SRCDIR) && $(MAKE) clean)

mv_OBJPATHS= $(mv_OBJDIR)/mv.o
mv_stub.c:
	echo "int _crunched_mv_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >mv_stub.c
mv.lo: mv_stub.o $(mv_OBJPATHS)
	ld -dc -r -o mv.lo mv_stub.o $(mv_OBJPATHS)
	crunchide -k _crunched_mv_stub mv.lo

# -------- ee

ee_SRCDIR=/usr/src/usr.bin/ee
ee_REALSRCDIR=/usr/src/usr.bin/ee
ee_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ee_REALSRCDIR)

ee_OBJS= ee.o
ee_make:
	(cd $(ee_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ee_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ee_OPTS) $(ee_OBJS))
ee_clean:
	(cd $(ee_SRCDIR) && $(MAKE) clean)

ee_OBJPATHS= $(ee_OBJDIR)/ee.o
ee_stub.c:
	echo "int _crunched_ee_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ee_stub.c
ee.lo: ee_stub.o $(ee_OBJPATHS)
	ld -dc -r -o ee.lo ee_stub.o $(ee_OBJPATHS)
	crunchide -k _crunched_ee_stub ee.lo

# -------- ftpd

ftpd_SRCDIR=/usr/src/libexec/ftpd
ftpd_REALSRCDIR=/usr/src/libexec/ftpd
ftpd_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ftpd_REALSRCDIR)

ftpd_OBJS= ftpd.o ftpcmd.o logwtmp.o popen.o skey-stuff.o ls.o cmp.o print.o util.o
ftpd_make:
	(cd $(ftpd_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ftpd_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ftpd_OPTS) $(ftpd_OBJS))
ftpd_clean:
	(cd $(ftpd_SRCDIR) && $(MAKE) clean)

ftpd_OBJPATHS= $(ftpd_OBJDIR)/ftpd.o $(ftpd_OBJDIR)/ftpcmd.o $(ftpd_OBJDIR)/logwtmp.o $(ftpd_OBJDIR)/popen.o $(ftpd_OBJDIR)/skey-stuff.o $(ftpd_OBJDIR)/ls.o $(ftpd_OBJDIR)/cmp.o $(ftpd_OBJDIR)/print.o $(ftpd_OBJDIR)/util.o
ftpd_stub.c:
	echo "int _crunched_ftpd_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ftpd_stub.c
ftpd.lo: ftpd_stub.o $(ftpd_OBJPATHS)
	ld -dc -r -o ftpd.lo ftpd_stub.o $(ftpd_OBJPATHS)
	crunchide -k _crunched_ftpd_stub ftpd.lo

# -------- pppd

pppd_SRCDIR=/usr/src/usr.sbin/pppd
pppd_REALSRCDIR=/usr/src/usr.sbin/pppd
pppd_OBJDIR=$(MAKEOBJDIRPREFIX)/$(pppd_REALSRCDIR)

pppd_OBJS= main.o magic.o fsm.o lcp.o ipcp.o ipxcp.o upap.o chap.o ccp.o demand.o auth.o options.o sys-bsd.o cbcp.o chap_ms.o
pppd_make:
	(cd $(pppd_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(pppd_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(pppd_OPTS) $(pppd_OBJS))
pppd_clean:
	(cd $(pppd_SRCDIR) && $(MAKE) clean)

pppd_OBJPATHS= $(pppd_OBJDIR)/main.o $(pppd_OBJDIR)/magic.o $(pppd_OBJDIR)/fsm.o $(pppd_OBJDIR)/lcp.o $(pppd_OBJDIR)/ipcp.o $(pppd_OBJDIR)/ipxcp.o $(pppd_OBJDIR)/upap.o $(pppd_OBJDIR)/chap.o $(pppd_OBJDIR)/ccp.o $(pppd_OBJDIR)/demand.o $(pppd_OBJDIR)/auth.o $(pppd_OBJDIR)/options.o $(pppd_OBJDIR)/sys-bsd.o $(pppd_OBJDIR)/cbcp.o $(pppd_OBJDIR)/chap_ms.o
pppd_stub.c:
	echo "int _crunched_pppd_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >pppd_stub.c
pppd.lo: pppd_stub.o $(pppd_OBJPATHS)
	ld -dc -r -o pppd.lo pppd_stub.o $(pppd_OBJPATHS)
	crunchide -k _crunched_pppd_stub pppd.lo

# -------- ldconfig

ldconfig_SRCDIR=/usr/src/sbin/ldconfig
ldconfig_REALSRCDIR=/usr/src/sbin/ldconfig
ldconfig_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ldconfig_REALSRCDIR)

ldconfig_OBJS= elfhints.o ldconfig.o shlib.o support.o
ldconfig_make:
	(cd $(ldconfig_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ldconfig_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ldconfig_OPTS) $(ldconfig_OBJS))
ldconfig_clean:
	(cd $(ldconfig_SRCDIR) && $(MAKE) clean)

ldconfig_OBJPATHS= $(ldconfig_OBJDIR)/elfhints.o $(ldconfig_OBJDIR)/ldconfig.o $(ldconfig_OBJDIR)/shlib.o $(ldconfig_OBJDIR)/support.o
ldconfig_stub.c:
	echo "int _crunched_ldconfig_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ldconfig_stub.c
ldconfig.lo: ldconfig_stub.o $(ldconfig_OBJPATHS)
	ld -dc -r -o ldconfig.lo ldconfig_stub.o $(ldconfig_OBJPATHS)
	crunchide -k _crunched_ldconfig_stub ldconfig.lo

# -------- pwd

pwd_SRCDIR=/usr/src/bin/pwd
pwd_REALSRCDIR=/usr/src/bin/pwd
pwd_OBJDIR=$(MAKEOBJDIRPREFIX)/$(pwd_REALSRCDIR)

pwd_OBJS= pwd.o
pwd_make:
	(cd $(pwd_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(pwd_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(pwd_OPTS) $(pwd_OBJS))
pwd_clean:
	(cd $(pwd_SRCDIR) && $(MAKE) clean)

pwd_OBJPATHS= $(pwd_OBJDIR)/pwd.o
pwd_stub.c:
	echo "int _crunched_pwd_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >pwd_stub.c
pwd.lo: pwd_stub.o $(pwd_OBJPATHS)
	ld -dc -r -o pwd.lo pwd_stub.o $(pwd_OBJPATHS)
	crunchide -k _crunched_pwd_stub pwd.lo

# -------- telnet

telnet_SRCDIR=/usr/src/usr.bin/telnet
telnet_REALSRCDIR=/usr/src/usr.bin/telnet
telnet_OBJDIR=$(MAKEOBJDIRPREFIX)/$(telnet_REALSRCDIR)

telnet_OBJS= authenc.o commands.o main.o network.o ring.o sys_bsd.o telnet.o terminal.o tn3270.o utilities.o
telnet_make:
	(cd $(telnet_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(telnet_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(telnet_OPTS) $(telnet_OBJS))
telnet_clean:
	(cd $(telnet_SRCDIR) && $(MAKE) clean)

telnet_OBJPATHS= $(telnet_OBJDIR)/authenc.o $(telnet_OBJDIR)/commands.o $(telnet_OBJDIR)/main.o $(telnet_OBJDIR)/network.o $(telnet_OBJDIR)/ring.o $(telnet_OBJDIR)/sys_bsd.o $(telnet_OBJDIR)/telnet.o $(telnet_OBJDIR)/terminal.o $(telnet_OBJDIR)/tn3270.o $(telnet_OBJDIR)/utilities.o
telnet_stub.c:
	echo "int _crunched_telnet_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >telnet_stub.c
telnet.lo: telnet_stub.o $(telnet_OBJPATHS)
	ld -dc -r -o telnet.lo telnet_stub.o $(telnet_OBJPATHS)
	crunchide -k _crunched_telnet_stub telnet.lo

# -------- less

less_SRCDIR=/usr/src/usr.bin/less
less_REALSRCDIR=/usr/src/usr.bin/less
less_OBJDIR=$(MAKEOBJDIRPREFIX)/$(less_REALSRCDIR)

less_OBJS= main.o screen.o brac.o ch.o charset.o cmdbuf.o command.o decode.o edit.o filename.o forwback.o help.o ifile.o input.o jump.o line.o linenum.o lsystem.o mark.o optfunc.o option.o opttbl.o os.o output.o position.o prompt.o search.o signal.o tags.o ttyin.o version.o
less_make:
	(cd $(less_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(less_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(less_OPTS) $(less_OBJS))
less_clean:
	(cd $(less_SRCDIR) && $(MAKE) clean)

less_OBJPATHS= $(less_OBJDIR)/main.o $(less_OBJDIR)/screen.o $(less_OBJDIR)/brac.o $(less_OBJDIR)/ch.o $(less_OBJDIR)/charset.o $(less_OBJDIR)/cmdbuf.o $(less_OBJDIR)/command.o $(less_OBJDIR)/decode.o $(less_OBJDIR)/edit.o $(less_OBJDIR)/filename.o $(less_OBJDIR)/forwback.o $(less_OBJDIR)/help.o $(less_OBJDIR)/ifile.o $(less_OBJDIR)/input.o $(less_OBJDIR)/jump.o $(less_OBJDIR)/line.o $(less_OBJDIR)/linenum.o $(less_OBJDIR)/lsystem.o $(less_OBJDIR)/mark.o $(less_OBJDIR)/optfunc.o $(less_OBJDIR)/option.o $(less_OBJDIR)/opttbl.o $(less_OBJDIR)/os.o $(less_OBJDIR)/output.o $(less_OBJDIR)/position.o $(less_OBJDIR)/prompt.o $(less_OBJDIR)/search.o $(less_OBJDIR)/signal.o $(less_OBJDIR)/tags.o $(less_OBJDIR)/ttyin.o $(less_OBJDIR)/version.o
less_stub.c:
	echo "int _crunched_less_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >less_stub.c
less.lo: less_stub.o $(less_OBJPATHS)
	ld -dc -r -o less.lo less_stub.o $(less_OBJPATHS)
	crunchide -k _crunched_less_stub less.lo

# -------- passwd

passwd_SRCDIR=/usr/src/usr.bin/passwd
passwd_REALSRCDIR=/usr/src/usr.bin/passwd
passwd_OBJDIR=$(MAKEOBJDIRPREFIX)/$(passwd_REALSRCDIR)

passwd_OBJS= local_passwd.o passwd.o pw_copy.o pw_util.o
passwd_make:
	(cd $(passwd_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(passwd_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(passwd_OPTS) $(passwd_OBJS))
passwd_clean:
	(cd $(passwd_SRCDIR) && $(MAKE) clean)

passwd_OBJPATHS= $(passwd_OBJDIR)/local_passwd.o $(passwd_OBJDIR)/passwd.o $(passwd_OBJDIR)/pw_copy.o $(passwd_OBJDIR)/pw_util.o
passwd_stub.c:
	echo "int _crunched_passwd_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >passwd_stub.c
passwd.lo: passwd_stub.o $(passwd_OBJPATHS)
	ld -dc -r -o passwd.lo passwd_stub.o $(passwd_OBJPATHS)
	crunchide -k _crunched_passwd_stub passwd.lo

# -------- date

date_SRCDIR=/usr/src/bin/date
date_REALSRCDIR=/usr/src/bin/date
date_OBJDIR=$(MAKEOBJDIRPREFIX)/$(date_REALSRCDIR)

date_OBJS= date.o netdate.o vary.o
date_make:
	(cd $(date_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(date_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(date_OPTS) $(date_OBJS))
date_clean:
	(cd $(date_SRCDIR) && $(MAKE) clean)

date_OBJPATHS= $(date_OBJDIR)/date.o $(date_OBJDIR)/netdate.o $(date_OBJDIR)/vary.o
date_stub.c:
	echo "int _crunched_date_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >date_stub.c
date.lo: date_stub.o $(date_OBJPATHS)
	ld -dc -r -o date.lo date_stub.o $(date_OBJPATHS)
	crunchide -k _crunched_date_stub date.lo

# -------- mount_cd9660

mount_cd9660_SRCDIR=/usr/src/sbin/mount_cd9660
mount_cd9660_REALSRCDIR=/usr/src/sbin/mount_cd9660
mount_cd9660_OBJDIR=$(MAKEOBJDIRPREFIX)/$(mount_cd9660_REALSRCDIR)

mount_cd9660_OBJS= mount_cd9660.o getmntopts.o
mount_cd9660_make:
	(cd $(mount_cd9660_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(mount_cd9660_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(mount_cd9660_OPTS) $(mount_cd9660_OBJS))
mount_cd9660_clean:
	(cd $(mount_cd9660_SRCDIR) && $(MAKE) clean)

mount_cd9660_OBJPATHS= $(mount_cd9660_OBJDIR)/mount_cd9660.o $(mount_cd9660_OBJDIR)/getmntopts.o
mount_cd9660_stub.c:
	echo "int _crunched_mount_cd9660_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >mount_cd9660_stub.c
mount_cd9660.lo: mount_cd9660_stub.o $(mount_cd9660_OBJPATHS)
	ld -dc -r -o mount_cd9660.lo mount_cd9660_stub.o $(mount_cd9660_OBJPATHS)
	crunchide -k _crunched_mount_cd9660_stub mount_cd9660.lo

# -------- mount_nfs

mount_nfs_SRCDIR=/usr/src/sbin/mount_nfs
mount_nfs_REALSRCDIR=/usr/src/sbin/mount_nfs
mount_nfs_OBJDIR=$(MAKEOBJDIRPREFIX)/$(mount_nfs_REALSRCDIR)

mount_nfs_OBJS= mount_nfs.o getmntopts.o mounttab.o
mount_nfs_make:
	(cd $(mount_nfs_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(mount_nfs_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(mount_nfs_OPTS) $(mount_nfs_OBJS))
mount_nfs_clean:
	(cd $(mount_nfs_SRCDIR) && $(MAKE) clean)

mount_nfs_OBJPATHS= $(mount_nfs_OBJDIR)/mount_nfs.o $(mount_nfs_OBJDIR)/getmntopts.o $(mount_nfs_OBJDIR)/mounttab.o
mount_nfs_stub.c:
	echo "int _crunched_mount_nfs_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >mount_nfs_stub.c
mount_nfs.lo: mount_nfs_stub.o $(mount_nfs_OBJPATHS)
	ld -dc -r -o mount_nfs.lo mount_nfs_stub.o $(mount_nfs_OBJPATHS)
	crunchide -k _crunched_mount_nfs_stub mount_nfs.lo

# -------- ping

ping_SRCDIR=/usr/src/sbin/ping
ping_REALSRCDIR=/usr/src/sbin/ping
ping_OBJDIR=$(MAKEOBJDIRPREFIX)/$(ping_REALSRCDIR)

ping_OBJS= ping.o
ping_make:
	(cd $(ping_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(ping_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(ping_OPTS) $(ping_OBJS))
ping_clean:
	(cd $(ping_SRCDIR) && $(MAKE) clean)

ping_OBJPATHS= $(ping_OBJDIR)/ping.o
ping_stub.c:
	echo "int _crunched_ping_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >ping_stub.c
ping.lo: ping_stub.o $(ping_OBJPATHS)
	ld -dc -r -o ping.lo ping_stub.o $(ping_OBJPATHS)
	crunchide -k _crunched_ping_stub ping.lo

# -------- traceroute

traceroute_SRCDIR=/usr/src/usr.sbin/traceroute
traceroute_REALSRCDIR=/usr/src/usr.sbin/traceroute
traceroute_OBJDIR=$(MAKEOBJDIRPREFIX)/$(traceroute_REALSRCDIR)

traceroute_OBJS= version.o traceroute.o
traceroute_make:
	(cd $(traceroute_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(traceroute_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(traceroute_OPTS) $(traceroute_OBJS))
traceroute_clean:
	(cd $(traceroute_SRCDIR) && $(MAKE) clean)

traceroute_OBJPATHS= $(traceroute_OBJDIR)/version.o $(traceroute_OBJDIR)/traceroute.o
traceroute_stub.c:
	echo "int _crunched_traceroute_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >traceroute_stub.c
traceroute.lo: traceroute_stub.o $(traceroute_OBJPATHS)
	ld -dc -r -o traceroute.lo traceroute_stub.o $(traceroute_OBJPATHS)
	crunchide -k _crunched_traceroute_stub traceroute.lo

# -------- tar

tar_SRCDIR=/usr/src/gnu/usr.bin/tar
tar_REALSRCDIR=/usr/src/gnu/usr.bin/tar
tar_OBJDIR=$(MAKEOBJDIRPREFIX)/$(tar_REALSRCDIR)

tar_OBJS= buffer.o create.o diffarch.o extract.o getdate.o getoldopt.o getopt.o getopt1.o gnu.o list.o mangle.o names.o port.o prepend_args.o rtapelib.o tar.o update.o version.o
tar_make:
	(cd $(tar_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(tar_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(tar_OPTS) $(tar_OBJS))
tar_clean:
	(cd $(tar_SRCDIR) && $(MAKE) clean)

tar_OBJPATHS= $(tar_OBJDIR)/buffer.o $(tar_OBJDIR)/create.o $(tar_OBJDIR)/diffarch.o $(tar_OBJDIR)/extract.o $(tar_OBJDIR)/getdate.o $(tar_OBJDIR)/getoldopt.o $(tar_OBJDIR)/getopt.o $(tar_OBJDIR)/getopt1.o $(tar_OBJDIR)/gnu.o $(tar_OBJDIR)/list.o $(tar_OBJDIR)/mangle.o $(tar_OBJDIR)/names.o $(tar_OBJDIR)/port.o $(tar_OBJDIR)/prepend_args.o $(tar_OBJDIR)/rtapelib.o $(tar_OBJDIR)/tar.o $(tar_OBJDIR)/update.o $(tar_OBJDIR)/version.o
tar_stub.c:
	echo "int _crunched_tar_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >tar_stub.c
tar.lo: tar_stub.o $(tar_OBJPATHS)
	ld -dc -r -o tar.lo tar_stub.o $(tar_OBJPATHS)
	crunchide -k _crunched_tar_stub tar.lo

# -------- grep

grep_SRCDIR=/usr/src/gnu/usr.bin/grep
grep_REALSRCDIR=/usr/src/gnu/usr.bin/grep
grep_OBJDIR=$(MAKEOBJDIRPREFIX)/$(grep_REALSRCDIR)

grep_OBJS= dfa.o getopt.o getopt1.o grep.o kwset.o obstack.o savedir.o search.o stpcpy.o
grep_make:
	(cd $(grep_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(grep_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(grep_OPTS) $(grep_OBJS))
grep_clean:
	(cd $(grep_SRCDIR) && $(MAKE) clean)

grep_OBJPATHS= $(grep_OBJDIR)/dfa.o $(grep_OBJDIR)/getopt.o $(grep_OBJDIR)/getopt1.o $(grep_OBJDIR)/grep.o $(grep_OBJDIR)/kwset.o $(grep_OBJDIR)/obstack.o $(grep_OBJDIR)/savedir.o $(grep_OBJDIR)/search.o $(grep_OBJDIR)/stpcpy.o
grep_stub.c:
	echo "int _crunched_grep_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >grep_stub.c
grep.lo: grep_stub.o $(grep_OBJPATHS)
	ld -dc -r -o grep.lo grep_stub.o $(grep_OBJPATHS)
	crunchide -k _crunched_grep_stub grep.lo

# -------- minigzip

minigzip_SRCDIR=/usr/src/usr.bin/minigzip
minigzip_REALSRCDIR=/usr/src/usr.bin/minigzip
minigzip_OBJDIR=$(MAKEOBJDIRPREFIX)/$(minigzip_REALSRCDIR)

minigzip_OBJS= minigzip.o
minigzip_make:
	(cd $(minigzip_SRCDIR) && $(MAKE) obj && \
		$(MAKE) $(BUILDOPTS) $(minigzip_OPTS) depend &&\
		$(MAKE) $(BUILDOPTS) $(minigzip_OPTS) $(minigzip_OBJS))
minigzip_clean:
	(cd $(minigzip_SRCDIR) && $(MAKE) clean)

minigzip_OBJPATHS= $(minigzip_OBJDIR)/minigzip.o
minigzip_stub.c:
	echo "int _crunched_minigzip_stub(int argc, char **argv, char **envp){return main(argc,argv,envp);}" >minigzip_stub.c
minigzip.lo: minigzip_stub.o $(minigzip_OBJPATHS)
	ld -dc -r -o minigzip.lo minigzip_stub.o $(minigzip_OBJPATHS)
	crunchide -k _crunched_minigzip_stub minigzip.lo

# ========