def METHOD_NAME(self):
    if not any(output.is_linked for output in self.outputs):
        return
    vertices_s = self.inputs['Vertices'].sv_get(deepcopy=False)
    edges_s = self.inputs['Edges'].sv_get(default=[[]], deepcopy=False)
    faces_s = self.inputs['Faces'].sv_get(deepcopy=False)
    masks_s = self.inputs['VertMask'].sv_get(default=[[1]], deepcopy=False)
    iterations_s = self.inputs['Iterations'].sv_get(deepcopy=False)
    factor_s = self.inputs['Factor'].sv_get(deepcopy=False)
    input_level = get_data_nesting_level(vertices_s)
    vertices_s = ensure_nesting_level(vertices_s, 4)
    edges_s = ensure_nesting_level(edges_s, 4)
    faces_s = ensure_nesting_level(faces_s, 4)
    masks_s = ensure_nesting_level(masks_s, 3)
    iterations_s = ensure_nesting_level(iterations_s, 2)
    factor_s = ensure_nesting_level(factor_s, 2)
    nested_output = input_level > 3
    used_axes = set()
    if self.use_x:
        used_axes.add(0)
    if self.use_y:
        used_axes.add(1)
    if self.use_z:
        used_axes.add(2)
    verts_out = []
    for params in zip_long_repeat(vertices_s, edges_s, faces_s, masks_s, iterations_s, factor_s):
        for vertices, edges, faces, mask, iterations, factor in zip_long_repeat(*params):
            if self.algorithm == 'LLOYD':
                vertices = lloyd_relax(vertices, faces, iterations,
                                mask = mask,
                                method = self.preserve_shape,
                                skip_boundary = self.skip_bounds,
                                use_axes = used_axes)
            elif self.algorithm == 'EDGES':
                vertices = edges_relax(vertices, edges, faces, iterations,
                                k = factor,
                                mask = mask,
                                method = self.preserve_shape,
                                target = self.target,
                                skip_boundary = self.skip_bounds,
                                use_axes = used_axes)
            elif self.algorithm == 'FACES':
                vertices = faces_relax(vertices, edges, faces, iterations,
                                k = factor,
                                mask = mask,
                                method = self.preserve_shape,
                                target = self.target,
                                skip_boundary = self.skip_bounds,
                                use_axes = used_axes)
            else:
                raise Exception("Unsupported algorithm")
        verts_out.append(vertices)
    self.outputs['Vertices'].sv_set(verts_out)