text:
package lib

import (
	"fmt"
	"os"
	"path/filepath"
	"strings"

	"github.com/namsral/flag"
)

// ReservedSpace -
const ReservedSpace int64 = 512 * 1024 * 1024 // 512Mb

// Config -
type Config struct {
	DryRun         bool     `json:"dryRun"`
	NotifyPlan     int      `json:"notifyPlan"`
	NotifyTransfer int      `json:"notifyTransfer"`
	ReservedAmount int64    `json:"reservedAmount"`
	ReservedUnit   string   `json:"reservedUnit"`
	RsyncArgs      []string `json:"rsyncArgs"`
	Version        string   `json:"version"`
	Verbosity      int      `json:"verbosity"`
	CheckForUpdate int      `json:"checkForUpdate"`
	RefreshRate    int      `json:"refreshRate"`
}

// NotifyPlan/NotifyTransfer possible values
// 0 - no notification
// 1 - simple notification
// 2 - detailed notification

// Settings -
type Settings struct {
	Config

	Port       string
	LogDir     string
	APIFolders []string

	Location string
	confName string
}

const defaultConfLocation = "/boot/config/plugins/unbalance"

// NewSettings -
func NewSettings(name, version string, locations []string) (*Settings, error) {
	var port, logDir, folders, rsyncArgs, apiFolders string
	var dryRun bool
	var notifyPlan, notifyTransfer, verbosity, checkForUpdate, refreshRate int
	var reservedAmount int64
	var reservedUnit string

	flagset := flag.NewFlagSet(os.Args[0], flag.ContinueOnError)

	flagset.StringVar(&port, "port", "6237", "port to run the server")
	flagset.StringVar(&logDir, "logdir", "/boot/logs", "pathname where log file will be written to")
	flagset.StringVar(&folders, "folders", "", "deprecated - do not use")
	flagset.BoolVar(&dryRun, "dryRun", true, "perform a dry-run rather than actual work")
	flagset.IntVar(&notifyPlan, "notifyPlan", 0, "notify via email after plan operation has completed (unraid notifications must be set up first): 0 - No notifications; 1 - Simple notifications; 2 - Detailed notifications")
	flagset.IntVar(&notifyTransfer, "notifyTransfer", 0, "notify via email after transfer operation has completed (unraid notifications must be set up first): 0 - No notifications; 1 - Simple notifications; 2 - Detailed notifications")
	flagset.StringVar(&rsyncArgs, "rsyncArgs", "-X", "custom rsync arguments")
	flagset.StringVar(&apiFolders, "apiFolders", "/var/local/emhttp", "folders to look for api endpoints")
	flagset.IntVar(&verbosity, "verbosity", 0, "include rsync output in log files: 0 (default) - include; 1 - do not include")
	flagset.IntVar(&checkForUpdate, "checkForUpdate", 1, "checkForUpdate: 0 - dont' check; 1 (default) - check")
	flagset.IntVar(&refreshRate, "refreshRate", 250, "how often to refresh the ui while running a command (in milliseconds)")

	// Users can set some value that falls below ReservedSpace, but during planning we force ReservedSpace if
	// reservation is less than that
	// Also, if they some unrecognized unit, we will used ReservedSpace (in planning as well)
	flagset.Int64Var(&reservedAmount, "reservedAmount", ReservedSpace/1024/1024, "Minimun Amount of space to reserve")
	flagset.StringVar(&reservedUnit, "reservedUnit", "Mb", "Reserved Amount unit: Mb, Gb or %")

	location := SearchFile(name, locations)
	if location != "" {
		flagset.String("config", filepath.Join(location, name), "config location")
	}

	if err := flagset.Parse(os.Args[1:]); err != nil {
		return nil, err
	}

	s := &Settings{}

	if rsyncArgs == "" {
		s.RsyncArgs = make([]string, 0)
	} else {
		s.RsyncArgs = strings.Split(rsyncArgs, "|")
	}

	s.DryRun = dryRun
	s.NotifyPlan = notifyPlan
	s.NotifyTransfer = notifyTransfer
	s.ReservedAmount = reservedAmount
	s.ReservedUnit = reservedUnit
	s.Verbosity = verbosity
	s.CheckForUpdate = checkForUpdate
	s.RefreshRate = refreshRate
	s.Version = version

	s.Port = port
	s.LogDir = logDir
	s.APIFolders = strings.Split(apiFolders, "|")
	s.Location = location
	s.confName = name

	return s, nil
}

// ToggleDryRun -
func (s *Settings) ToggleDryRun() {
	s.DryRun = !s.DryRun
}

// Save -
func (s *Settings) Save() (err error) {
	location := s.Location
	if location == "" {
		location = defaultConfLocation
	}

	confLocation := filepath.Join(location, s.confName)
	tmpFile := confLocation + ".tmp"

	if err = WriteLine(tmpFile, fmt.Sprintf("dryRun=%t", s.DryRun)); err != nil {
		return err
	}

	if err = WriteLine(tmpFile, fmt.Sprintf("notifyPlan=%d", s.NotifyPlan)); err != nil {
		return err
	}

	if err = WriteLine(tmpFile, fmt.Sprintf("notifyTransfer=%d", s.NotifyTransfer)); err != nil {
		return err
	}

	rsyncArgs := strings.Join(s.RsyncArgs, "|")
	if err = WriteLine(tmpFile, fmt.Sprintf("rsyncArgs=%s", rsyncArgs)); err != nil {
		return err
	}

	if err = WriteLine(tmpFile, fmt.Sprintf("verbosity=%d", s.Verbosity)); err != nil {
		return err
	}

	if err = WriteLine(tmpFile, fmt.Sprintf("refreshRate=%d", s.RefreshRate)); err != nil {
		return err
	}

	if err = WriteLine(tmpFile, fmt.Sprintf("reservedAmount=%d", s.ReservedAmount)); err != nil {
		return err
	}

	if err = WriteLine(tmpFile, fmt.Sprintf("reservedUnit=%s", s.ReservedUnit)); err != nil {
		return err
	}

	err = os.Rename(tmpFile, confLocation)
	if err != nil {
		return err
	}

	return err
}

repository: jbrodriguez/unbalance

repo_name: jbrodriguez/unbalance


text:
//
// Created by Yaser Alkayale on 2017-07-18.
//

#include "catch.hpp"
#include "../lib/experiments/hungarian.h"
#include "../lib/algorithm/kmeans_data.h"

TEST_CASE("Perfect Matching Works") {
  auto infinity = std::numeric_limits<kmeans::Distance>::max();
  kmeans::Matrix<kmeans::Distance> matrix{{0, 0,  0,  0},
                                          {0, 12, 15, 8},
                                          {0, 15, 17, 1},
                                          {0, 8,  3,  11}};
  matrix = {
      {1,2,3},
      {3,1,2},
      {3,2,1}
  };
  auto result = kmeans::experiments::minimumWeightPerfectMatching(matrix);

  //for(const auto &i:result) {
  //  std::cout << std::get<0>(i)<<", "<<std::get<1>(i) << "\t";
  //}

}

license: MIT

repository: technoligest/kmeansII

license_type: permissive

repo_name: technoligest/kmeansII

branch_name: refs/heads/master

extension: cc


text:
package web

import (
	"fmt"
	"net/http"
	"strings"
	"time"
)

var gmtZone *time.Location

func init() {
	var err error
	gmtZone, err = time.LoadLocation("GMT")
	if err != nil {
		gmtZone = time.UTC
	}
}

// HeaderHandler returns an http.Handler that adds the given headers to the response.
func HeaderHandler(h http.Handler, headers map[string]string) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		for k, v := range headers {
			w.Header().Set(k, v)
		}
		h.ServeHTTP(w, r)
	})
}

// ExpiresHandler adds the expires header choosing expires for dynamic content
// and staticExpires for static content.
func ExpiresHandler(h http.Handler, expires, staticExpires time.Duration) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		expiry := staticExpires
		if strings.HasSuffix(r.URL.Path, "/") || strings.HasSuffix(r.URL.Path, ".html") || r.URL.Path == "/sitemap.txt" {
			expiry = expires
		}
		if expiry != 0 {
			// w.Header().Set("Expires", time.Now().Add(expiry).In(gmtZone).Format(time.RFC1123))
			w.Header().Set("Cache-Control", fmt.Sprintf("max-age=%d", int64(expiry.Seconds())))
		}
		h.ServeHTTP(w, r)
	})
}

repository: ancientlore/whisper

repo_name: ancientlore/whisper

gha_license_id: NOASSERTION

gha_language: Go

extension: go


text:
@book{Menezes:1996:HAC:548089,
 author = {Menezes, Alfred J. and Vanstone, Scott A. and Oorschot, Paul C. Van},
 title = {Handbook of Applied Cryptography},
 year = {1996},
 isbn = {0849385237},
 edition = {1st},
 publisher = {CRC Press, Inc.},
 address = {Boca Raton, FL, USA},
}

@book{Rosen:2012,
 author = {Rosen, Kenneth H.},
 title = {Discrete Mathematics and Its Applications},
 year = {2012},
 isbn = {978-0073383095},
 edition = {7th},
 publisher = {McGraw-Hill Higher Education},
}

@ARTICLE{ref:Elgamal1985,
author={Elgamal, T.},
journal={Information Theory, IEEE Transactions on},
title={A public key cryptosystem and a signature scheme based on discrete logarithms},
year={1985},
volume={31},
number={4},
pages={469-472},
keywords={Cryptography;Logarithmic arithmetic;Digital signatures;Galois fields;Helium;Information security;Information systems;Milling machines;Public key;Public key cryptography},
doi={10.1109/TIT.1985.1057074},
ISSN={0018-9448},}

extension: bib


text:
// Copyright 2016 Palantir Technologies, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package builtintasks

import (
	"github.com/palantir/godel/v2/framework/builtintasks/githubwiki"
	"github.com/palantir/godel/v2/framework/godellauncher"
	"github.com/pkg/errors"
	"github.com/spf13/cobra"
)

func GitHubWikiTask() godellauncher.Task {
	var githubWikiParams githubwiki.Params

	const (
		docsDirFlag        = "docs-dir"
		repoFlag           = "repository"
		authorNameFlag     = "author-name"
		authorEmailFlag    = "author-email"
		committerNameFlag  = "committer-name"
		committerEmailFlag = "committer-email"
		msgFlag            = "message"
	)

	cmd := &cobra.Command{
		Use:   "github-wiki",
		Short: "Push contents of a documents directory to a GitHub Wiki repository",
		RunE: func(cmd *cobra.Command, args []string) error {
			return githubwiki.SyncGitHubWiki(githubWikiParams, cmd.OutOrStdout())
		},
	}

	cmd.Flags().StringVar(&githubWikiParams.DocsDir, docsDirFlag, "", "Directory whose contents should be pushed to the GitHub Wiki repository")
	cmd.Flags().StringVar(&githubWikiParams.Repo, repoFlag, "", "GitHub wiki repository address (for example, git@github.com:org/project.wiki.git)")
	cmd.Flags().StringVar(&githubWikiParams.AuthorName, authorNameFlag, "", "Author name to use for commit (if blank, uses value of last commit in current project)")
	cmd.Flags().StringVar(&githubWikiParams.AuthorEmail, authorEmailFlag, "", "Author email to use for commit (if blank, uses value of last commit in current project)")
	cmd.Flags().StringVar(&githubWikiParams.CommitterName, committerNameFlag, "", "Committer name to use for commit (if blank, uses value of last commit in current project)")
	cmd.Flags().StringVar(&githubWikiParams.CommitterEmail, committerEmailFlag, "", "Committer email to use for commit (if blank, uses value of last commit in current project)")
	cmd.Flags().StringVar(&githubWikiParams.Msg, msgFlag, `Sync documentation using godel github-wiki task ({{ printf "%.7s" .CommitID}})`, "Commit message to use for commit in GitHub Wiki repository")

	if err := cmd.MarkFlagRequired(docsDirFlag); err != nil {
		panic(errors.Wrapf(err, "failed to mark flag %s as required", docsDirFlag))
	}
	if err := cmd.MarkFlagRequired(repoFlag); err != nil {
		panic(errors.Wrapf(err, "failed to mark flag %s as required", repoFlag))
	}

	return godellauncher.CobraCLITask(cmd, nil)
}

repository: palantir/godel

repo_name: palantir/godel


text:
DESCRIPTION = "ChannelF emulator for libretro"

LICENSE = "GPL-3.0-only"
LIC_FILES_CHKSUM = "file://LICENSE;md5=2f5b803c8170f71ee6bf8ed95ce49be9"

inherit libretro

LIBRETRO_GIT_REPO = "github.com/libretro/FreeChaF.git"

gha_license_id: MIT

gha_language: BitBake

extension: bb


text:
package pool

//ByteChanPool is a simple pool of []byte using a channel
type ByteChanPool struct {
	sliceSize int
	poolSize  int
	pool      chan []byte
}

//NewByteChanPool...
func NewByteChanPool(poolSize, sliceSize int) *ByteChanPool {
	return &ByteChanPool{
		sliceSize: sliceSize,
		poolSize:  poolSize,
		pool:      make(chan []byte, poolSize),
	}
}

//Get returns a cleared []byte
func (b *ByteChanPool) Get() (value []byte) {
	select {
	case value = <-b.pool:
		//this will be optimied into a memclr call by the compiler
		for i, _ := range value {
			value[i] = 0
		}
		//resize the slice, this will panic if the slice doesn't have the capacity
		value = value[:b.sliceSize]
		return value
	default:
		return make([]byte, b.sliceSize)
	}
}

//Put adds a slice to the pool
func (b *ByteChanPool) Put(value []byte) {
	select {
	case b.pool <- value:
		//put on pool
	default:
		//drop value
	}
	return
}

//Size...
func (b ByteChanPool) Size() int {
	return len(b.pool)
}

repository: vrecan/poolShark

repo_name: vrecan/poolShark


text:
SUMMARY = "A console development image with bluetooth support"

require console-image.bb

BT = " \
    bluez5 \
    bluez5-dev \
    bluez5-noinst-tools \
    bluez5-obex \
    bluez5-testtools \
"

PYTHON_BT = " \
    python3-pybluez \
    python3-pygatt \
    python3-pygattlib \
"

IMAGE_INSTALL += " \
    ${BT} \
    ${PYTHON_BT} \
"

export IMAGE_BASENAME = "bt-image"

repository: jumpnow/meta-bbb

repo_name: jumpnow/meta-bbb

branch_name: refs/heads/dunfell

gha_language: Shell


text:
// Code generated by generate_structs - DO NOT EDIT.

package xivapi

type MobHuntTarget struct {
	Url string `json:"Url,omitempty"`
	FATE struct {
		ArrayIndex struct {
			MULTIREF2 int `json:"MULTIREF2,omitempty"`
			MULTIREF3 int `json:"MULTIREF3,omitempty"`
			MULTIREF5 int `json:"MULTIREF5,omitempty"`
			MULTIREF9 int `json:"MULTIREF9,omitempty"`
			MULTIREF10 int `json:"MULTIREF10,omitempty"`
			ID int `json:"ID,omitempty"`
			MULTIREF0 int `json:"MULTIREF0,omitempty"`
			MULTIREF13 int `json:"MULTIREF13,omitempty"`
			MULTIREF4 int `json:"MULTIREF4,omitempty"`
			MULTIREF6 int `json:"MULTIREF6,omitempty"`
			MULTIREF8 int `json:"MULTIREF8,omitempty"`
			MULTIREF1 int `json:"MULTIREF1,omitempty"`
			MULTIREF11 int `json:"MULTIREF11,omitempty"`
			MULTIREF12 int `json:"MULTIREF12,omitempty"`
			MULTIREF14 int `json:"MULTIREF14,omitempty"`
			MULTIREF15 int `json:"MULTIREF15,omitempty"`
			MULTIREF7 int `json:"MULTIREF7,omitempty"`
		}
		Name_de string `json:"Name_de,omitempty"`
		Objective_de string `json:"Objective_de,omitempty"`
		IconObjectiveID int `json:"IconObjectiveID,omitempty"`
		Objective_en string `json:"Objective_en,omitempty"`
		StatusText0_en string `json:"StatusText0_en,omitempty"`
		ArrayIndexTarget string `json:"ArrayIndexTarget,omitempty"`
		ArrayIndexTargetID int `json:"ArrayIndexTargetID,omitempty"`
		Description string `json:"Description,omitempty"`
		Description_fr string `json:"Description_fr,omitempty"`
		IconMapID int `json:"IconMapID,omitempty"`
		StatusText0_fr string `json:"StatusText0_fr,omitempty"`
		StatusText2_fr string `json:"StatusText2_fr,omitempty"`
		StatusText2_ja string `json:"StatusText2_ja,omitempty"`
		StatusText1_fr string `json:"StatusText1_fr,omitempty"`
		ClassJobLevel int `json:"ClassJobLevel,omitempty"`
		EurekaFate int `json:"EurekaFate,omitempty"`
		Name string `json:"Name,omitempty"`
		Objective string `json:"Objective,omitempty"`
		StatusText0_ja string `json:"StatusText0_ja,omitempty"`
		ID int `json:"ID,omitempty"`
		IconMap string `json:"IconMap,omitempty"`
		Name_fr string `json:"Name_fr,omitempty"`
		Objective_fr string `json:"Objective_fr,omitempty"`
		StatusText1_ja string `json:"StatusText1_ja,omitempty"`
		StatusText1_en string `json:"StatusText1_en,omitempty"`
		StatusText2 string `json:"StatusText2,omitempty"`
		StatusText2_de string `json:"StatusText2_de,omitempty"`
		Description_en string `json:"Description_en,omitempty"`
		IconObjective string `json:"IconObjective,omitempty"`
		Music struct {
			File string `json:"File,omitempty"`
			File_en string `json:"File_en,omitempty"`
			ID int `json:"ID,omitempty"`
		}
		MusicTargetID int `json:"MusicTargetID,omitempty"`
		StatusText1_de string `json:"StatusText1_de,omitempty"`
		StatusText2_en string `json:"StatusText2_en,omitempty"`
		ClassJobLevelMax int `json:"ClassJobLevelMax,omitempty"`
		Description_de string `json:"Description_de,omitempty"`
		Description_ja string `json:"Description_ja,omitempty"`
		EventItem int `json:"EventItem,omitempty"`
		StatusText1 string `json:"StatusText1,omitempty"`
		StatusText0_de string `json:"StatusText0_de,omitempty"`
		Location int `json:"Location,omitempty"`
		Name_en string `json:"Name_en,omitempty"`
		Name_ja string `json:"Name_ja,omitempty"`
		Objective_ja string `json:"Objective_ja,omitempty"`
		StatusText0 string `json:"StatusText0,omitempty"`
		MusicTarget string `json:"MusicTarget,omitempty"`
	}
	FATETarget string `json:"FATETarget,omitempty"`
	Icon string `json:"Icon,omitempty"`
	NameTarget string `json:"NameTarget,omitempty"`
	PlaceNameTarget string `json:"PlaceNameTarget,omitempty"`
	TerritoryTypeTargetID int `json:"TerritoryTypeTargetID,omitempty"`
	IconID int `json:"IconID,omitempty"`
	PlaceNameTargetID int `json:"PlaceNameTargetID,omitempty"`
	TerritoryTypeTarget string `json:"TerritoryTypeTarget,omitempty"`
	TerritoryType struct {
		MapFilename string `json:"MapFilename,omitempty"`
		MapFilenameId string `json:"MapFilenameId,omitempty"`
		MapMarkerRange int `json:"MapMarkerRange,omitempty"`
		OffsetX int `json:"OffsetX,omitempty"`
		PlaceNameTarget string `json:"PlaceNameTarget,omitempty"`
		TerritoryType struct {
			ArrayEventHandler int `json:"ArrayEventHandler,omitempty"`
			Bg string `json:"Bg,omitempty"`
			ID int `json:"ID,omitempty"`
			Map int `json:"Map,omitempty"`
			Name string `json:"Name,omitempty"`
			PlaceNameRegion int `json:"PlaceNameRegion,omitempty"`
			TerritoryIntendedUse int `json:"TerritoryIntendedUse,omitempty"`
			Aetheryte int `json:"Aetheryte,omitempty"`
			Bg_en string `json:"Bg_en,omitempty"`
			Name_en string `json:"Name_en,omitempty"`
			PlaceName int `json:"PlaceName,omitempty"`
			PlaceNameZone int `json:"PlaceNameZone,omitempty"`
			WeatherRate int `json:"WeatherRate,omitempty"`
		}
		TerritoryTypeTarget string `json:"TerritoryTypeTarget,omitempty"`
		Hierarchy int `json:"Hierarchy,omitempty"`
		PlaceNameSub int `json:"PlaceNameSub,omitempty"`
		ID int `json:"ID,omitempty"`
		OffsetY int `json:"OffsetY,omitempty"`
		PlaceName struct {
			Name_en string `json:"Name_en,omitempty"`
			Icon string `json:"Icon,omitempty"`
			Name string `json:"Name,omitempty"`
			NameNoArticle string `json:"NameNoArticle,omitempty"`
			NameNoArticle_de string `json:"NameNoArticle_de,omitempty"`
			NameNoArticle_en string `json:"NameNoArticle_en,omitempty"`
			NameNoArticle_ja string `json:"NameNoArticle_ja,omitempty"`
			Name_de string `json:"Name_de,omitempty"`
			ID int `json:"ID,omitempty"`
			NameNoArticle_fr string `json:"NameNoArticle_fr,omitempty"`
			Name_fr string `json:"Name_fr,omitempty"`
			Name_ja string `json:"Name_ja,omitempty"`
		}
		PlaceNameRegionTarget string `json:"PlaceNameRegionTarget,omitempty"`
		PlaceNameRegionTargetID int `json:"PlaceNameRegionTargetID,omitempty"`
		DiscoveryArrayByte int `json:"DiscoveryArrayByte,omitempty"`
		DiscoveryIndex int `json:"DiscoveryIndex,omitempty"`
		PlaceNameRegion struct {
			Icon string `json:"Icon,omitempty"`
			NameNoArticle string `json:"NameNoArticle,omitempty"`
			NameNoArticle_de string `json:"NameNoArticle_de,omitempty"`
			NameNoArticle_en string `json:"NameNoArticle_en,omitempty"`
			Name_de string `json:"Name_de,omitempty"`
			Name_en string `json:"Name_en,omitempty"`
			Name_fr string `json:"Name_fr,omitempty"`
			Name_ja string `json:"Name_ja,omitempty"`
			ID int `json:"ID,omitempty"`
			Name string `json:"Name,omitempty"`
			NameNoArticle_fr string `json:"NameNoArticle_fr,omitempty"`
			NameNoArticle_ja string `json:"NameNoArticle_ja,omitempty"`
		}
		PlaceNameTargetID int `json:"PlaceNameTargetID,omitempty"`
		SizeFactor int `json:"SizeFactor,omitempty"`
		TerritoryTypeTargetID int `json:"TerritoryTypeTargetID,omitempty"`
	}
	FATETargetID int `json:"FATETargetID,omitempty"`
	GameContentLinks []interface{} `json:"GameContentLinks,omitempty"`
	ID int `json:"ID,omitempty"`
	Name struct {
		Name_ja string `json:"Name_ja,omitempty"`
		Plural string `json:"Plural,omitempty"`
		Plural_en string `json:"Plural_en,omitempty"`
		Plural_fr string `json:"Plural_fr,omitempty"`
		StartsWithVowel int `json:"StartsWithVowel,omitempty"`
		ID int `json:"ID,omitempty"`
		Name string `json:"Name,omitempty"`
		Name_en string `json:"Name_en,omitempty"`
		Name_fr string `json:"Name_fr,omitempty"`
		Plural_de string `json:"Plural_de,omitempty"`
		Plural_ja string `json:"Plural_ja,omitempty"`
		Icon string `json:"Icon,omitempty"`
		Name_de string `json:"Name_de,omitempty"`
	}
	NameTargetID int `json:"NameTargetID,omitempty"`
	PlaceName struct {
		NameNoArticle_de string `json:"NameNoArticle_de,omitempty"`
		NameNoArticle_en string `json:"NameNoArticle_en,omitempty"`
		NameNoArticle_ja string `json:"NameNoArticle_ja,omitempty"`
		Name_en string `json:"Name_en,omitempty"`
		Name_ja string `json:"Name_ja,omitempty"`
		Icon string `json:"Icon,omitempty"`
		NameNoArticle string `json:"NameNoArticle,omitempty"`
		NameNoArticle_fr string `json:"NameNoArticle_fr,omitempty"`
		Name_de string `json:"Name_de,omitempty"`
		Name_fr string `json:"Name_fr,omitempty"`
		ID int `json:"ID,omitempty"`
		Name string `json:"Name,omitempty"`
	}
}

repository: Zyian/xivapi-go

repo_name: Zyian/xivapi-go