diff --git a/work/compute.c b/../molden-6.9/work/molden6.9/src/surf/compute.c
index dddcdc2..26f6f07 100644
--- a/work/compute.c
+++ b/../molden-6.9/work/molden6.9/src/surf/compute.c
@@ -23,6 +23,9 @@ Vector           Bounding_Tetra[4];
 double           Extents[3][2];
 short            Neighbor_list[MAX_CONSTRAINT];
 
+void find_components(int atom_id, Vector *cons);
+void find_tes_origin(int atom_id, Vector *cons);
+void compute_components(int atom_id, Vector *constraints);
 /*---------------------------------------------------------------------------------
 init_and_compute initializes the data structures and starts off the computation.
 ----------------------------------------------------------------------------------*/
@@ -202,7 +205,7 @@ compute_bounding_tetra()
 compute_components is in some sense the central routine. This makes calls to others
 for computing the surface.
 ----------------------------------------------------------------------------------*/
-compute_components(atom_id, constraints)
+void compute_components(atom_id, constraints)
 int		atom_id;
 Vector		*constraints;
 { 
@@ -582,7 +585,7 @@ find_components identifies the arcs formed by the intersection of the feasible c
 with the extended-radius sphere of atom atom_id and accordingly makes appropriate 
 calls to generates the patches.
 ----------------------------------------------------------------------------------*/
-find_components(atom_id, cons)
+void find_components(atom_id, cons)
 int		atom_id;
 Vector		*cons;
 { 
@@ -627,7 +630,7 @@ This assumes that int_pts, end_pts, etc, are in local coord system
 (the origin of the system is the center of the atom atom_id).
 This returns tes_origin in global coord system.
 ----------------------------------------------------------------------------------*/
-find_tes_origin(atom_id, cons)
+void find_tes_origin(atom_id, cons)
 int			atom_id;
 Vector			*cons;
 { 
diff --git a/work/tessel_concave.c b/../molden-6.9/work/molden6.9/src/surf/tessel_concave.c
index 8ae5606..5f6324b 100644
--- a/work/tessel_concave.c
+++ b/../molden-6.9/work/molden6.9/src/surf/tessel_concave.c
@@ -8,7 +8,11 @@ spherical triangular patches of the molecular surface.
 
 #include "surf.h"
 
+void gen_spherical_recurse(VertexType **points, double *sq_side_len, float *center, double radius, int convex);
 
+void gen_cuspy_concave_tri(VertexType point0, VertexType point1, VertexType point2, int flip, POINT center, double radius, Vector *plane_eq);
+
+void gen_cuspy_spherical_recurse(VertexType **points, double *sq_side_len, float *center, Vector *plane_eq, double radius);
 /*--------------------------------------------------------------------------------
 gen_concave generates a concave spherical triangular patch of the molecular surface.
 At present it can only handle simple cusps -- those which are due to two concave
@@ -105,7 +109,7 @@ double		radius;
 gen_cuspy_concave_tri generates a concave spherical triangular patch which might 
 have a cusp.
 ----------------------------------------------------------------------------------*/
-gen_cuspy_concave_tri(point0, point1, point2, flip, center, radius, plane_eq)
+void gen_cuspy_concave_tri(point0, point1, point2, flip, center, radius, plane_eq)
 VertexType	point0, point1, point2;
 int		flip;
 POINT		center;
@@ -161,7 +165,7 @@ gen_cuspy_spherical_recurse generates a spherical triangular patch which might h
 cusp. This recursively subdivides the patch while clipping it with its intersection 
 with plane represented by plane_eq.
 ----------------------------------------------------------------------------------*/
-gen_cuspy_spherical_recurse(points, sq_side_len, center, plane_eq, radius)
+void gen_cuspy_spherical_recurse(points, sq_side_len, center, plane_eq, radius)
 VertexType		*points[3];
 double			sq_side_len[3];
 float			center[3];
@@ -285,7 +289,7 @@ int			convex;
 gen_spherical_recurse generates a spherical triangular patch by recursively 
 subdividing till all its edge lengths are below a user specified threshold.
 ----------------------------------------------------------------------------------*/
-gen_spherical_recurse(points, sq_side_len, center, radius, convex)
+void gen_spherical_recurse(points, sq_side_len, center, radius, convex)
 VertexType		*points[3];
 float			center[3];
 double			radius;
diff --git a/work/tessel_convex.c b/../molden-6.9/work/molden6.9/src/surf/tessel_convex.c
index db592c9..76a6f7e 100644
--- a/work/tessel_convex.c
+++ b/../molden-6.9/work/molden6.9/src/surf/tessel_convex.c
@@ -15,7 +15,7 @@ gen_convex generates convex spherical patches that join torus ends to the
 regular atom surface.
 Here, p = sph_pts, q = tor_pts
 ----------------------------------------------------------------------------------*/
-gen_convex(comp_verts, p, probe_centers, q, num_p, num_q, same_order, flip, atom_id, full_torus)
+void gen_convex(comp_verts, p, probe_centers, q, num_p, num_q, same_order, flip, atom_id, full_torus)
 POINT		*comp_verts, *probe_centers; 
 VertexType	*p, *q;
 int		num_p, num_q;
diff --git a/work/tessel_torus.c b/../molden-6.9/work/molden6.9/src/surf/tessel_torus.c
index e386335..55e3355 100644
--- a/work/tessel_torus.c
+++ b/../molden-6.9/work/molden6.9/src/surf/tessel_torus.c
@@ -151,7 +151,7 @@ int		atom_id;
 gen_torus is used to smoothly tessellate the toroidal patches.
  radius : how "thick" the torus is (Probe Radius for us)
 ----------------------------------------------------------------------------------*/
-gen_torus(tor_pts, probe_centers, num_verts, flip, radius, cusp)
+void gen_torus(tor_pts, probe_centers, num_verts, flip, radius, cusp)
 VertexType	**tor_pts;
 POINT		*probe_centers;
 int		num_verts;