# Config for C++ (non-python) gtp bot

# RUNNING ON AN ONLINE SERVER OR IN A REAL TOURNAMENT OR MATCH:
# If you plan to do so, you may want to read through the "Rules" section
# below carefully for proper handling of komi and handicap games and end-of-game cleanup
# and various other details.

# NOTES ABOUT PERFORMANCE AND MEMORY USAGE:
# You will likely want to tune one or more the following:
#
# numSearchThreads:
# The number of CPU threads to use. If your GPU is powerful, it can actually be much higher than
# the number of cores on your processor because you will need many threads to feed large enough
# batches to make good use of the GPU.
#
# The "./katago benchmark" command can help you tune this parameter, as well as to test out the effect
# of changes to any of the other parameters below!
#
# nnCacheSizePowerOfTwo:
# This controls the NN Cache size, which is the primary RAM/memory use.
# Increase this if you don't mind the memory use and want better performance for searches with
# tens of thousands of visits or more. Decrease this if you want to limit memory usage.
#
# If you're someone who is happy to do a bit of math - each neural net entry takes very
# approximately 1.5KB, except when using whole-board ownership/territory visualizations, each
# entry will take very approximately 3KB. The number of entries is (2 ** nnCacheSizePowerOfTwo),
# for example 2 ** 18 = 262144.
#
# OTHER NOTES:
# If you have more than one GPU, take a look at "OpenCL GPU settings" or "CUDA GPU settings" below.
#
# If using OpenCL, you will want to verify that KataGo is picking up the correct device!
# (e.g. some systems may have both an Intel CPU OpenCL and GPU OpenCL, if KataGo appears to pick
# the wrong one, you correct this by specifying "openclGpuToUse" below).
#
# You may also want to adjust "maxVisits", "ponderingEnabled", "resignThreshold", and possibly
# other parameters depending on your intended usage.
#
# ----------------------------------------------------------------------------------------

# For the `katago gtp` command, ALL of THE BELOW VALUES MAY BE SET OR OVERRIDDEN if desired via
# the command line arguments:
# -override-config KEY=VALUE,KEY=VALUE,...

# Logs and files--------------------------------------------------------------------------

# Where to output log?
logDir = gtp_logs    # Each run of KataGo will log to a separate file in this dir
# logFile = gtp.log  # Use this instead of logDir to just specify a single file directly

# Logging options
logAllGTPCommunication = true
logSearchInfo = true
logToStderr = false

# KataGo will display some info to stderr on GTP startup
# Uncomment this to suppress that and remain silent
# startupPrintMessageToStderr = false

# Chat some stuff to stderr, for use in things like malkovich chat to OGS.
# ogsChatToStderr = true

# Optionally override where KataGo will attempt to save things like openCLTuner files and other cached data.
# homeDataDir = DIRECTORY

# Analysis------------------------------------------------------------------------------------

# Configure the maximum length of analysis printed out by lz-analyze and other places.
# Controls the number of moves after the first move in a variation.
 analysisPVLen = 50

# Report winrates for chat and analysis as (BLACK|WHITE|SIDETOMOVE).
# Default is SIDETOMOVE, which is what tools that use LZ probably also expect
# reportAnalysisWinratesAs = SIDETOMOVE

# Larger values will make KataGo explore the top move(s) less deeply and accurately,
# but explore and give evaluations to a greater variety of moves, for analysis (does NOT affect play).
# Defaults to 0.04.
# An extreme value like 1 will distribute many playouts across every move on the board, even very bad moves.

#  analysisWideRootNoise = 0.0580997925519935
#  analysisWideRootNoise = 0.05809979255189344
#  analysisWideRootNoise = 0.0580997925518934
#  analysisWideRootNoise = 0.058099792551893391
#  analysisWideRootNoise = 0.05809979255189339
#  analysisWideRootNoise = 0.058099792551893389
#  analysisWideRootNoise = 0.05809979255189338886
   analysisWideRootNoise = 0.05809979255189338887
#  analysisWideRootNoise = 0.058099792551893388484
#  analysisWideRootNoise = 0.058099792551893388
#  analysisWideRootNoise = 0.05809979255189337


# Default rules------------------------------------------------------------------------------------
# See https://lightvector.github.io/KataGo/rules.html for a description of the rules.
# These rules are defaults and can be changed mid-run by several custom GTP commands.
# See https://github.com/lightvector/KataGo/blob/master/docs/GTP_Extensions.md for those commands.

# Some other legal values are: "chinese", "japanese", "korean", "aga", "chinese-ogs", "new-zealand".
# KataGo does not claim to exactly match any particular human ruleset, but KataGo will try to behave
# as closely as possible given the rules it has implemented.
rules = tromp-taylor

# Use the below instead to specify an arbitrary combination of individual rules.

# koRule = SIMPLE       # Simple ko rules (triple ko = no result)
# koRule = POSITIONAL   # Positional superko
# koRule = SITUATIONAL  # Situational superko

# scoringRule = AREA       # Area scoring
# scoringRule = TERRITORY  # Territory scoring (uses a sort of special computer-friendly territory ruleset)

# taxRule = NONE  # All surrounded empty points are scored
# taxRule = SEKI  # Eyes in seki do NOT count as points
# taxRule = ALL   # All groups are taxed up to 2 points for the two eyes needed to live

# multiStoneSuicideLegal = false  # Is multiple-stone suicide legal? (Single-stone suicide is always illegal).

# hasButton = false # Set to true when area scoring to award 0.5 points to the first pass.

# friendlyPassOk = true  # Set to true except for computer rulesets that requires capturing all stones before passing.

# whiteHandicapBonus = 0    # In handicap games, give white no compensation for black's handicap stones (Tromp-taylor, NZ, JP)
# whiteHandicapBonus = N-1  # In handicap games, give white N-1 points for black's handicap stones (AGA)
# whiteHandicapBonus = N    # In handicap games, give white N points for black's handicap stones (Chinese)

# Uncomment and change to adjust what board size KataGo uses upon startup by default if GTP doesn't specify.
# defaultBoardSize = 19
# Specify this to force a particular komi, EVEN if the GUI or GTP controller tries to set a different one
# ignoreGTPAndForceKomi = 7

# Bot behavior---------------------------------------------------------------------------------------

# Resignation -------------

# Resignation occurs if for at least resignConsecTurns in a row,
# the winLossUtility (which is on a [-1,1] scale) is below resignThreshold.
allowResignation = true
resignThreshold = -0.90
resignConsecTurns = 3
# Uncomment to make katago not resign close games, behind by fewer than this many points
 resignMinScoreDifference = 10

# Handicap -------------

# Assume that if black makes many moves in a row right at the start of the game, then the game is a handicap game.
# This is necessary on some servers and for some GUIs and also when initializing from many SGF files, which may
# set up a handicap game using repeated GTP "play" commands for black rather than GTP "place_free_handicap" commands.
# However, it may also lead to incorrect understanding of komi if whiteHandicapBonus is used and a server does NOT
# have such a practice.
# Defaults to true! Uncomment and set to false to disable this behavior.
# assumeMultipleStartingBlackMovesAreHandicap = true

# Makes katago dynamically adjust in handicap or altered-komi games to assume based on those game settings that it
# must be stronger or weaker than the opponent and to play accordingly. Greatly improves handicap
# strength by biasing winrates and scores to favor appropriate safe/aggressive play.
# Does NOT affect analysis (lz-analyze, kata-analyze, used by programs like Lizzie) so analysis remains unbiased.
# Uncomment and set this to 0 to disable this and make KataGo play the same always.
 dynamicPlayoutDoublingAdvantageCapPerOppLead = 0.045

# Instead of a dynamic level, you can uncomment this and set this to a value from -3.0 to 3.0 to set KataGo's aggression to a FIXED level.
# DOES affect analysis tools (lz-analyze, kata-analyze, used by programs like Lizzie).
# Negative makes KataGo behave as if it is much weaker than the opponent, preferring to play defensively.
# Positive makes KataGo behave as if it is much stronger than the opponent, prefering to play aggressively or even overplay slightly.
# If this and "dynamicPlayoutDoublingAdvantageCapPerOppLead" are BOTH set then dynamic will be used for all games and this fixed
# value will be used for analysis tools.
# playoutDoublingAdvantage = 0.0

# Uncommenting one of these will enforce that the FIXED playoutDoublingAdvantage will only apply when KataGo plays the specified color
# and will be negated when playing the opposite color.
# playoutDoublingAdvantagePla = BLACK
# playoutDoublingAdvantagePla = WHITE

# Passing and cleanup -------------

# Make the bot never assume that its pass will end the game, even if passing would end and "win" under Tromp-Taylor rules.
# Usually this is a good idea when using it for analysis or playing on servers where scoring may be implemented non-tromp-taylorly.
# Defaults to true! Uncomment and set to false to disable this.
# conservativePass = true

# When using territory scoring, self-play games continue beyond two passes with special cleanup
# rules that may be confusing for human players. This option prevents the special cleanup phases from being
# reachable when using the bot for GTP play.
# Defaults to true! Uncomment and set to false if you want KataGo to be able to enter special cleanup.
# For example, if you are testing it against itself, or against another bot that has precisely implemented the rules
# documented at https://lightvector.github.io/KataGo/rules.html
# preventCleanupPhase = true

# Misc Behavior --------------------

# If the board is symmetric, search only one copy of each equivalent move. Attempts to also account for ko/superko, will not theoretically perfect for superko.
# Uncomment and set to false to disable this.
 rootSymmetryPruning = true

# Uncomment and set to true to make KataGo avoid a particular joseki that some KataGo nets misevaluate,
# and also to improve opening diversity versus some particular other bots that like to play it all the time.
 avoidMYTDaggerHack = true

# Have KataGo mildly prefer to avoid playing the same joseki in every corner of the board.
# Uncomment to set to a specific value. Otherwise, defaults to 0 in even games, and to 0.005 in handicap games.
# See also the Avoid SGF mechanism at the bottom of this config.

# avoidRepeatedPatternUtility = 0.0

# Experimental logic to make KataGo fight a bit against mirror Go even with unfavorable komi.
# Enabled by default for GTP play, disabled for GTP analysis (i.e lizzie) and analysis engine.
# Uncomment and set to true to enable it for analysis, or false to disable it fully.
 antiMirror = true

# Search limits-----------------------------------------------------------------------------------

# For all of "maxVisits", "maxPlayouts", "maxTime", search will still try to follow GTP time controls and may make a move
# faster than the specified max if GTP tells it that it is playing under a clock as well in the current game.

# If provided, limit maximum number of root visits per search to this much. (With tree reuse, visits do count earlier search)
# maxVisits = 7500
# If provided, limit maximum number of new playouts per search to this much. (With tree reuse, playouts do not count earlier search)
 maxPlayouts = 10000
# If provided, cap search time at this many seconds.
# maxTime = 20

# Ponder on the opponent's turn?
ponderingEnabled = true
maxTimePondering = 3600  # Maximum time to ponder, in seconds. Comment out to make unlimited.
# Note: you can set "maxVisitsPondering" or "maxPlayoutsPondering" too.

# Approx number of seconds to buffer for lag for GTP time controls - will move a bit faster assuming there is this much lag per move.
lagBuffer = 1.0

# Number of threads to use in search
numSearchThreads = 18

# Play a little faster if the opponent is passing, for friendliness
searchFactorAfterOnePass = 0.50
searchFactorAfterTwoPass = 0.25
# Play a little faster if super-winning, for friendliness
# searchFactorWhenWinning = 0.875
searchFactorWhenWinning = 0.87429
searchFactorWhenWinningThreshold = 0.99

# GPU Settings-------------------------------------------------------------------------------

# Maximum number of positions to send to a single GPU at once.
# The default value here is roughly equal to numSearchThreads, but you can specify it manually
# if you are running out of memory, or if you are using multiple GPUs that expect to split
# up the work.
 nnMaxBatchSize = 8

# Cache up to (2 ** this) many neural net evaluations in case of transpositions in the tree.
# Uncomment and edit to change if you want to adjust a major component of KataGo's RAM usage.
 nnCacheSizePowerOfTwo = 23

# Size of mutex pool for nnCache is (2 ** this).
 nnMutexPoolSizePowerOfTwo = 23

# Randomize board orientation when running neural net evals? Uncomment and set to false to disable.
 nnRandomize = true
# If provided, force usage of a specific seed for nnRandomize instead of randomizing.
# nnRandSeed = 048d422

# TO USE MULTIPLE GPUS:
# Set this to the number of GPUs you have and/or would like to use.
# **AND** if it is more than 1, uncomment the appropriate CUDA or OpenCL section below.
 numNNServerThreadsPerModel = 1


# TENSORRT GPU settings--------------------------------------
# These only apply when using the TENSORRT version of KataGo.

# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
# trtDeviceToUse = 0

# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1

# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
# trtDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
# trtDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
# trtDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2

# You can probably guess the pattern if you have four, five, etc. GPUs.


# CUDA GPU settings--------------------------------------
# These only apply when using the CUDA version of KataGo.

# IF USING ONE GPU: optionally uncomment and change this if the GPU you want to use turns out to be not device 0
# cudaDeviceToUse = 0

# IF USING TWO GPUS: Uncomment these two lines (AND set numNNServerThreadsPerModel above):
# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1

# IF USING THREE GPUS: Uncomment these three lines (AND set numNNServerThreadsPerModel above):
# cudaDeviceToUseThread0 = 0  # change this if the first GPU you want to use turns out to be not device 0
# cudaDeviceToUseThread1 = 1  # change this if the second GPU you want to use turns out to be not device 1
# cudaDeviceToUseThread2 = 2  # change this if the third GPU you want to use turns out to be not device 2

# You can probably guess the pattern if you have four, five, etc. GPUs.

# KataGo will automatically use FP16 or not based on the compute capability of your NVIDIA GPU. If you
# want to try to force a particular behavior though you can uncomment these lines and change them
# to "true" or "false". E.g. it's using FP16 but on your card that's giving an error, or it's not using
# FP16 but you think it should.
# cudaUseFP16 = auto
# cudaUseNHWC = auto


# OpenCL GPU settings--------------------------------------
# These only apply when using the OpenCL version of KataGo.

# Uncomment to tune OpenCL for every board size separately, rather than only the largest possible size
# openclReTunePerBoardSize = true

# IF USING ONE GPU: optionally uncomment and change this if the best device to use is guessed incorrectly.
# The default behavior tries to guess the 'best' GPU or device on your system to use, usually it will be a good guess.
# openclDeviceToUse = 0

# IF USING TWO GPUS: Uncomment these two lines and replace X and Y with the device ids of the devices you want to use.
# It might NOT be 0 and 1, some computers will have many OpenCL devices. You can see what the devices are when
# KataGo starts up - it should print or log all the devices it finds.
# (AND also set numNNServerThreadsPerModel above)
# openclDeviceToUseThread0 = X
# openclDeviceToUseThread1 = Y

# IF USING THREE GPUS: Uncomment these three lines and replace X and Y and Z with the device ids of the devices you want to use.
# It might NOT be 0 and 1 and 2, some computers will have many OpenCL devices. You can see what the devices are when
# KataGo starts up - it should print or log all the devices it finds.
# (AND also set numNNServerThreadsPerModel above)
# openclDeviceToUseThread0 = X
# openclDeviceToUseThread1 = Y
# openclDeviceToUseThread2 = Z

# You can probably guess the pattern if you have four, five, etc. GPUs.

# KataGo will automatically use FP16 or not based on testing your GPU during tuning. If you
# want to try to force a particular behavior though you can uncomment this lines and change it
# to "true" or "false". This is a fairly blunt setting - more detailed settings are testable
# by rerunning the tuner with various arguments.
# openclUseFP16 = auto


# Eigen-specific settings--------------------------------------
# These only apply when using the Eigen (pure CPU) version of KataGo.

# This is the number of CPU threads for evaluating the neural net on the Eigen backend.
# It defaults to numSearchThreads.
# numEigenThreadsPerModel = X


# Root move selection and biases------------------------------------------------------------------------------
# Uncomment and edit any of the below values to change them from their default.

# If provided, force usage of a specific seed for various things in the search instead of randomizing
 searchRandSeed = 2424111

# Temperature for the early game, randomize between chosen moves with this temperature

 chosenMoveTemperatureEarly = 0.271610768

# Decay temperature for the early game by 0.5 every this many moves, scaled with board size.

 chosenMoveTemperatureHalflife = 25

# At the end of search after the early game, randomize between chosen moves with this temperature

# chosenMoveTemperature = 0.336256
 chosenMoveTemperature = 0.33625555525772753
# chosenMoveTemperature = 0.336255
# chosenMoveTemperature = 0.336254

# Subtract this many visits from each move prior to applying chosenMoveTemperature
# (unless all moves have too few visits) to downweight unlikely moves

 chosenMoveSubtract = 5

# The same as chosenMoveSubtract but only prunes moves that fall below the threshold, does not affect moves above

 chosenMovePrune = 5

# Number of symmetries to sample (WITHOUT replacement) and average at the root
# rootNumSymmetriesToSample = 1

# Using LCB for move selection?
 useLcbForSelection = true
# How many stdevs a move needs to be better than another for LCB selection

  lcbStdevs = 3.5470708125176722185

# Only use LCB override when a move has this proportion of visits as the top move

 minVisitPropForLCB = 0.1361950325

# Internal params------------------------------------------------------------------------------
# Uncomment and edit any of the below values to change them from their default.

# Scales the utility of winning/losing
# winLossUtilityFactor = 1.0
# Scales the utility for trying to maximize score

 staticScoreUtilityFactor = 0.18733825
 dynamicScoreUtilityFactor = 0.168645

# Adjust dynamic score center this proportion of the way towards zero, capped at a reasonable amount.

 dynamicScoreCenterZeroWeight = 0.1905
 dynamicScoreCenterScale = 0.542

# The utility of getting a "no result" due to triple ko or other long cycle in non-superko rulesets (-1 to 1)
# noResultUtilityForWhite = 0.0
# The number of wins that a draw counts as, for white. (0 to 1)
# drawEquivalentWinsForWhite = 0.5

# Exploration constant for mcts

# cpuctExploration = 0.0808614281301
# cpuctExploration = 0.08086142813
# cpuctExploration = 0.0808614281299
# cpuctExploration = 0.08086142812987
# cpuctExploration = 0.08086142812986
# cpuctExploration = 0.08086142812985
# cpuctExploration = 0.080861428129845
# cpuctExploration = 0.080861428129844
# cpuctExploration = 0.080861428129843
# cpuctExploration = 0.080861428129842
# cpuctExploration = 0.080861428129841
# cpuctExploration = 0.08086142812984
# cpuctExploration = 0.080861428129839
# cpuctExploration = 0.080861428129838
# cpuctExploration = 0.080861428129837
# cpuctExploration = 0.0808614281298365
 cpuctExploration = 0.080861428129836
# cpuctExploration = 0.0808614281298
# cpuctExploration = 0.0808614281297
# cpuctExploration = 0.080861428129

 cpuctExplorationLog = 7.1280650261719275
# cpuctExplorationLog = 7.128065026171927
# cpuctExplorationLog = 7.1280650261719265
# cpuctExplorationLog = 7.128065026171926
# cpuctExplorationLog = 7.128065026171925
# cpuctExplorationLog = 7.12806502617192424
# cpuctExplorationLog = 7.12806502617192423
# cpuctExplorationLog = 7.12806502617192422
# cpuctExplorationLog = 7.12806502617192421
# cpuctExplorationLog = 7.1280650261719242
# cpuctExplorationLog = 7.128065026171924218
# cpuctExplorationLog = 7.128065026171924217
# cpuctExplorationLog = 7.128065026171924216
# cpuctExplorationLog = 7.128065026171924215
# cpuctExplorationLog = 7.128065026171924214
# cpuctExplorationLog = 7.128065026171924213
# cpuctExplorationLog = 7.128065026171924212
# cpuctExplorationLog = 7.128065026171924211
# cpuctExplorationLog = 7.12806502617192421
# cpuctExplorationLog = 7.1280650261719242
# cpuctExplorationLog = 7.128065026171924

# Parameters that control exploring more in volatile positions, exploring less in stable positions.

# cpuctUtilityStdevPrior = 0.40
 cpuctUtilityStdevPriorWeight = 1.98037671723
# cpuctUtilityStdevScale = 0.85

# FPU reduction constant for mcts

# fpuReductionMax = 0.1751448714291
# fpuReductionMax = 0.175144871429
# fpuReductionMax = 0.1751448714289
# fpuReductionMax = 0.1751448714288
# fpuReductionMax = 0.1751448714287
# fpuReductionMax = 0.1751448714286
# fpuReductionMax = 0.1751448714285
# fpuReductionMax = 0.1751448714284
# fpuReductionMax = 0.1751448714283
# fpuReductionMax = 0.1751448714282
# fpuReductionMax = 0.1751448714281
# fpuReductionMax = 0.175144871428
 fpuReductionMax = 0.1751448714279
# fpuReductionMax = 0.1751448714278
# fpuReductionMax = 0.175144871
# fpuReductionMax = 0.17514487

# rootFpuReductionMax = 0.08451372449698
# rootFpuReductionMax = 0.084513724496977
 rootFpuReductionMax = 0.0845137244969769
# rootFpuReductionMax = 0.084513724496976
# rootFpuReductionMax = 0.084513724496975
# rootFpuReductionMax = 0.08451372449697
# rootFpuReductionMax = 0.08451372449696
# rootFpuReductionMax = 0.084513724496955
# rootFpuReductionMax = 0.084513724496954
# rootFpuReductionMax = 0.084513724496953
# rootFpuReductionMax = 0.084513724496952
# rootFpuReductionMax = 0.084513724496951
# rootFpuReductionMax = 0.08451372449695
# rootFpuReductionMax = 0.08451372449695
# rootFpuReductionMax = 0.08451372449694


fpuParentWeightByVisitedPolicy = false


# Parameters that control weighting of evals based on the net's own self-reported uncertainty.
# useUncertainty = true
# uncertaintyExponent = 1.0
# uncertaintyCoeff = 0.25

# Amount to apply a downweighting of children with very bad values relative to good ones

  valueWeightExponent = 0.5221181682161
#   valueWeightExponent = 0.522118168216092
# valueWeightExponent = 0.522118168216005
# valueWeightExponent = 0.522118168216
# valueWeightExponent = 0.522118168215995

# Slight incentive for the bot to behave human-like with regard to passing at the end, filling the dame,
# not wasting time playing in its own territory, etc, and not play moves that are equivalent in terms of
# points but a bit more unfriendly to humans.

 rootEndingBonusPoints = 0.675

# Make the bot prune useless moves that are just prolonging the game to avoid losing yet
 rootPruneUselessMoves = true

# Apply bias correction based on local pattern keys
 subtreeValueBiasFactor = 0.35
 subtreeValueBiasWeightExponent = 0.8


# Use graph search rather than tree search - identify and share search for transpositions.
useGraphSearch = true


# How much to shard the node table for search synchronization
nodeTableShardsPowerOfTwo = 24


# How many virtual losses to add when a thread descends through a node
# numVirtualLossesPerThread = 1

# Improve the quality of evals under heavy multithreading
 useNoisePruning = true


# Avoid SGF Patterns ------------------------------------------------------------------------------
# The parameters in this section provide a powerful way to customize KataGo to avoid moves that follow specific patterns
# based on a set of provided SGF files loaded upon startup. Uncomment them to use this feature.
# Additionally, if the SGF file contains the string %SKIP% in a comment on a move, that move will be ignored for this purpose.

# Load sgf files from this directory when the engine is started (ONLY on startup, will not reload unless engine is restarted)
# avoidSgfPatternDirs = path/to/directory/with/sgfs/

# Penalize this much utility per matching move.
# Set this negative if you instead want to make KataGo favor the SGF patterns instead of penalizing it!
# This number does not need to be large, even 0.001 will make a difference. Too-large values may lead to bad play.
# avoidSgfPatternUtility = 0.001

# Optional - load only the newest this many files
# avoidSgfPatternMaxFiles = 20

# Optional - Penalty is multiplied by this per each older SGF file, so that old sgf files matter less than newer ones.
# avoidSgfPatternLambda = 0.90

# Optional - pay attention only to moves that were made by players with this name.
# For example you can set it to the name that your bot's past games will show up as in the SGF, so that the bot will only avoid repeating
# moves that itself made in past games, not the moves that its opponents made.
# avoidSgfPatternAllowedNames = my-ogs-bot-name1,my-ogs-bot-name2

# Optional - Ignore any moves in SGF files that occurred before this turn number.
# avoidSgfPatternMinTurnNumber = 0

# For more avoid patterns:
# You can also specify a second set of parameters, and a third, fourth, etc by numbering 2,3,4,...
# avoidSgf2PatternDirs = ...
# avoidSgf2PatternUtility = ...
# avoidSgf2PatternMaxFiles = ...
# avoidSgf2PatternLambda = ...
# avoidSgf2PatternAllowedNames = ...
# avoidSgf2PatternMinTurnNumber = ...