ModuleVersionIdentifier id = projectPublication.getCoordinates(ModuleVersionIdentifier.class);
            if (id != null) {
                gradlePublications.add(new DefaultGradlePublication()
                        .setId(new DefaultGradleModuleVersion(id))
                        .setProjectIdentifier(projectIdentifier)
                );
            }
        }

        return gradlePublications;
    }

     *
     * Can be null on a newly created matcher, but must be set in order to be considered valid.
     */
    @Nullable
    String getId();

    /**
     * Sets the id of the matcher type.
     *
     * @param id the id, cannot be null
     */
    void setId(String id);

    /**
     * The arguments of the matcher or null if it has children.
     */
    @Nullable
    String getArguments();

        this();
        this.id = id;
        this.arguments = arguments;
        this.children = children;
    }

    @Override
    public String getId() {
        return id;
    }

    @Override
    public void setId(String id) {
        this.id = id;
    }

    @Override
    @Nullable
    public String getArguments() {
        return arguments;
    }

    @Override

            Model m = new Model();
            m.setArtifactId(ARTIFACT_ID);
            m.setGroupId(GROUP_ID);
            m.setVersion(VERSION);
            Repository repository = new Repository();
            repository.setId(REPO_ID);
            repository.setUrl(REPO_URL);
            repository.setLayout(REPO_LAYOUT);
            m.getRepositories().add(repository);
            return m;
        }
        return null;
    }

    public void stop() {
        ComponentUtil.getJobManager().findJobByUniqueOf(LaJobUnique.of(getId())).ifPresent(job -> {
            job.stopNow();
        }).orElse(() -> {
            throw new JobNotFoundException(this);
        });
    }

    public String getId() {
        return asDocMeta().id();
    }

    public void setId(final String id) {
        asDocMeta().id(id);
    }

    public Long getVersionNo() {

        for (int i = 0; i < len; i = i + 2) {
            lifecyclePhaseBindings.put(pluginBindings[i], new LifecyclePhase(pluginBindings[i + 1]));
        }

        Lifecycle lifecycle = new Lifecycle();
        lifecycle.setId("default");
        lifecycle.setLifecyclePhases(Collections.unmodifiableMap(lifecyclePhaseBindings));

        this.lifecycleMapping = new DefaultLifecycleMapping(Collections.singletonList(lifecycle));
    }

        plugin.setArtifactId(artifactId);

        for (String goal : goals) {
            PluginExecution pluginExecution = new PluginExecution();
            pluginExecution.setId("default-" + goal);
            pluginExecution.addGoal(goal);
            plugin.addExecution(pluginExecution);
        }

        return plugin;
    }

                            tree.send(new SmbComClose(sess.getConfig(), resp2.getFid(), 0L));
                        }
                    }
                }
                finally {
                    if ( resp != null && !trans.isDisconnected() ) {
                        tree.send(new SmbComClose(sess.getConfig(), resp.getFid(), 0L));
                    }
                }
            }
            else {

                    Map<String, LifecyclePhase> phases = getLifecyclePhases(lifecycleId);
                    if (phases != null) {
                        Lifecycle lifecycle = new Lifecycle();

                        lifecycle.setId(lifecycleId);
                        lifecycle.setLifecyclePhases(phases);

                        lifecycleMap.put(lifecycleId, lifecycle);
                    }
                }
            }
        }
    }

	register("Segv", Segv)
}

var Sum int

func Segv() {
	c := make(chan bool)
	go func() {
		close(c)
		for i := 0; ; i++ {
			Sum += i
		}
	}()

	<-c

	syscall.Kill(syscall.Getpid(), syscall.SIGSEGV)

	// Wait for the OS to deliver the signal.
	select {}